Download (3398Kb)
Download (3398Kb)
Download (3398Kb)
Erfolgreiche ePaper selbst erstellen
Machen Sie aus Ihren PDF Publikationen ein blätterbares Flipbook mit unserer einzigartigen Google optimierten e-Paper Software.
OPTIMIERUNG DER MATERIALISIERTEN<br />
SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM<br />
ÜBERNOMMENEN OPERATIVEN DATEN
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
INHALTSVERZEICHNIS:<br />
1 EINFÜHRUNG ........................................................................16<br />
1.1 ZIEL DER ARBEIT ............................................................................. 16<br />
1.2 VORGEHENSWEISE ........................................................................... 16<br />
2 DATENMODELLIERUNG........................................................17<br />
2.1 SEMANTISCHES DATENMODELL ........................................................ 17<br />
2.1.1 ENTITÄTEN (ENTITIES) .......................................................................... 18<br />
2.1.2 ENTITÄTSMENGEN (ENTITY SETS) ........................................................ 18<br />
2.1.3 ATTRIBUTE UND SCHLÜSSEL.................................................................. 19<br />
2.1.4 BEZIEHUNGEN (RELATIONSHIPS) .......................................................... 20<br />
2.1.5 KARDINALITÄTEN VON BEZIEHUNGEN.................................................. 21<br />
2.1.5.1 1-1 BEZIEHUNGEN........................................................................... 21<br />
2.1.5.2 1-N BEZIEHUNGEN .......................................................................... 22<br />
2.1.5.3 M-N BEZIEHUNGEN......................................................................... 22<br />
2.1.5.4 DIE REKURSIVE BEZIEHUNG ........................................................ 22<br />
2.2 LOGISCHES DATENMODELL.............................................................. 23<br />
2.2.1 ALLGEMEINES ........................................................................................ 23<br />
2.2.2 DATENMODELLE..................................................................................... 24<br />
2.2.2.1 HIERARCHISCHES DATENMODELL.............................................. 24<br />
2.2.2.2 NETZWERKDATENMODELL ........................................................... 25<br />
2.2.2.3 RELATIONALES DATENMODELL................................................... 25<br />
2.2.2.4 OBJEKTORIENTIERTES DATENMODELL ..................................... 26<br />
2.2.2.5 OBJEKTRELATIONALES DATENMODELL..................................... 27<br />
2.2.3 ÜBERFÜHRUNG DES ER-MODELLS INS RELATIONALE MODELL.......... 27<br />
2.2.3.1 DIE UMSETZUNG DER 1:1 BEZIEHUNG....................................... 29<br />
2.2.3.2 DIE UMSETZUNG DER 1:N BEZIEHUNG ...................................... 30<br />
2.2.3.3 DIE UMSETZUNG DER M:N BEZIEHUNG..................................... 30<br />
- 2 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
2.2.3.4 DIE UMSETZUNG EINER REKURSIVEN BEZIEHUNG................. 31<br />
2.3 PHYSISCHES DATENMODELL............................................................. 31<br />
3 SQL UND DATENBANKEN ....................................................32<br />
3.1 DATENBANKEN ................................................................................ 32<br />
3.1.1 ENTWICKLUNGSGESCHICHTE DER DATENBANKSYSTEME.................... 32<br />
3.1.2 BEGRIFFSDEFINITIONEN ........................................................................ 32<br />
3.1.3 ANFORDERUNGEN EINES DATENBANKSYSTEMS.................................... 33<br />
3.2 SQL ALS STANDARDISIERTE DATENBANKSPRACHE............................. 34<br />
3.2.1 GESCHICHTLICHES................................................................................. 34<br />
3.2.2 DAS RELATIONALE MODELL ................................................................. 36<br />
3.2.2.1 RELATIONALE DATENSTRUKTUR ................................................. 36<br />
3.2.2.1.1 DOMÄNEN:.................................................................................... 36<br />
3.2.2.1.2 RELATIONEN: ............................................................................... 36<br />
3.2.2.1.3 EIGENSCHAFTEN VON RELATIONEN............................................ 37<br />
3.2.2.2 RELATIONALE INTEGRITÄT ........................................................... 38<br />
3.2.2.2.1 SCHLÜSSELKANDIDAT (CANDIDATE KEY).................................... 38<br />
3.2.2.2.2 PRIMÄRSCHLÜSSEL (PRIMARY KEY)............................................ 38<br />
3.2.2.2.3 FREMDSCHLÜSSEL (FOREIGN KEY).............................................. 38<br />
3.2.2.2.4 ENTITÄTSINTEGRITÄT.................................................................. 38<br />
3.2.2.2.5 REFERENZIELLE INTEGRITÄT (REFERENTIAL INTEGRITY) ........ 38<br />
3.2.2.3 RELATIONALE DATENMANIPULATION ........................................ 39<br />
3.2.2.4 NORMALFORMEN ............................................................................ 40<br />
3.2.2.4.1 ERSTE NORMALFORM (1NF) ....................................................... 40<br />
3.2.2.4.2 ZWEITE NORMALFORM (2NF)..................................................... 40<br />
3.2.2.4.3 DRITTE NORMALFORM (3NF) ..................................................... 40<br />
3.2.2.4.4 BOYCE-CODD-NORMALFORM (BCNF)....................................... 41<br />
3.2.2.4.5 VOR- UND NACHTEILE DER NORMALISIERUNG .......................... 41<br />
3.2.2.5 SICHTEN (VIEWS)............................................................................. 41<br />
- 3 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
3.2.2.5.1 TERMINOLOGIE ............................................................................ 41<br />
3.2.2.5.2 ZWECK VON SICHTEN .................................................................. 42<br />
3.2.2.5.3 AKTUALISIERUNG VON SICHTEN ................................................. 42<br />
3.2.3 SQL NACH DEM STANDARD SQL 99 ..................................................... 42<br />
3.2.3.1 SQL ALS DDL..................................................................................... 43<br />
3.2.3.1.1 ERZEUGEN VON DBMS-OBJEKTEN (CREATE)......................... 43<br />
3.2.3.1.2 ÄNDERN VON DBMS-OBJEKTEN (ALTER)................................ 43<br />
3.2.3.1.3 VERGABE VON RECHTEN (GRANT) ........................................... 44<br />
3.2.3.1.4 ENTZIEHEN VON RECHTEN (REVOKE) ..................................... 44<br />
3.2.3.2 SQL ALS DML .................................................................................... 44<br />
3.2.3.2.1 DIE SELECT ABFRAGE............................................................... 44<br />
3.2.3.2.2 DIE INSERT ANWEISUNG ........................................................... 45<br />
3.2.3.2.3 DIE UPDATE ANWEISUNG ......................................................... 45<br />
3.2.3.2.4 DIE DELETE ANWEISUNG.......................................................... 45<br />
3.2.3.3 SQL ALS DCL..................................................................................... 45<br />
4 ERP-SYSTEME......................................................................46<br />
5 DAS DATA WAREHOUSE ......................................................47<br />
5.1 DAS KONZEPT DES DATA WAREHOUSE ............................................. 47<br />
5.2 ARCHITEKTUR EINES DATAWAREHOUSE ............................................ 48<br />
5.2.1 OPERATIVE DATEN ................................................................................ 49<br />
5.2.2 EXTERNE DATENBANKEN....................................................................... 50<br />
5.2.3 DIE METADATEN .................................................................................... 50<br />
5.2.4 DIE DATENPUMPEN ................................................................................ 50<br />
5.2.5 DER DATAWAREHOUSE MANAGER........................................................ 50<br />
5.2.6 ZUGRIFFSWERKZEUGE FÜR DEN ENDBENUTZER................................... 50<br />
5.2.6.1 WERKZEUGE FÜR BERICHTE UND ABFRAGEN ......................... 51<br />
5.2.6.2 WERKZEUGE ZUR ENTWICKLUNG VON ANWENDUNGEN ....... 51<br />
5.2.6.3 EXECUTIVE INFORMATION SYSTEM WERKZEUGE (EIS).......... 51<br />
- 4 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
5.2.6.4 DECISION SUPPORT SYSTEME (DSS)............................................ 52<br />
5.2.6.5 ONLINE ANALYTICAL PROCESSING WERKZEUGE (OLAP) ....... 52<br />
5.2.6.6 DATA MINING WERKZEUGE .......................................................... 52<br />
5.3 OPERATIVE UND ANALYTISCHE DATEN .............................................. 53<br />
5.4 AUFBAUEN UND AKTUALISIEREN EINES DATAWAREHOUSE AUS DEN<br />
DATENQUELLEN......................................................................................... 55<br />
5.4.1 KLASSISCHE VORGEHENSWEISE BEIM AUFBAUEN UND AKTUALISIEREN<br />
EINES DATAWAREHOUSE........................................................................................ 55<br />
5.4.2 NEUE ANSÄTZE FÜR DAS AUFBAUEN UND AKTUALISIEREN DER<br />
MATERIALISIERTEN SICHTEN ................................................................................ 55<br />
5.4.2.1 DER WHIPS PROTOTYP................................................................... 56<br />
5.4.2.2 DER SUMMARY TABLE ANSATZ ..................................................... 58<br />
5.4.2.3 DER MULTIPLE VIEW MAINTENANCE POLICIES ANSATZ ........ 59<br />
5.5 INFORMATIONSFLÜSSE IN EINEM DATA WAREHOUSE ......................... 60<br />
5.5.1 INFLOW................................................................................................... 60<br />
5.5.2 UPFLOW.................................................................................................. 61<br />
5.5.3 DOWNFLOW............................................................................................ 61<br />
5.5.4 OUTFLOW ............................................................................................... 61<br />
5.5.5 METAFLOW ............................................................................................ 61<br />
5.6 PROBLEME IM DATA WAREHOUSE .................................................... 62<br />
5.7 VORTEILE EINES DATAWAREHOUSE................................................... 63<br />
5.8 ANFORDERUNGEN AN EIN DATENBANKSYSTEM FÜR EIN<br />
DATAWAREHOUSE ...................................................................................... 64<br />
5.9 DATA MARTS .................................................................................... 66<br />
5.10 DIE MODELLIERUNG EINES DATAWAREHOUSE............................... 67<br />
5.10.1 MODELLTHEORIE................................................................................... 67<br />
5.10.2 ATTRIBUTE ............................................................................................. 68<br />
5.10.3 DIMENSIONEN UND HIERARCHIEN......................................................... 68<br />
5.10.4 DIE DATENWÜRFEL................................................................................ 69<br />
- 5 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
5.10.5 OPERATOREN ......................................................................................... 70<br />
5.10.6 SLICE AND DICE ..................................................................................... 71<br />
5.10.7 NAVIGATION DURCH DEN DATENBESTAND............................................ 72<br />
5.10.8 KONZEPTIONELLE ODER SEMANTISCHE MODELLIERUNG ................... 73<br />
5.10.8.1 GRAPHISCHE MODELLIERUNG ................................................ 73<br />
5.10.8.2 HALBGRAPHISCHE MODELLIERUNG ...................................... 75<br />
5.10.8.2.1 GITTER ....................................................................................... 75<br />
5.10.8.2.2 AGGREGATION PATH ARRAY .................................................... 76<br />
5.10.9 LOGISCHE UND PHYSIKALISCHE MODELLIERUNG ............................... 76<br />
5.10.9.1 STAR-SCHEMA .............................................................................. 76<br />
5.10.9.2 FACT CONSTELLATION-SCHEMA.............................................. 78<br />
5.10.9.3 SNOWFLAKE-SCHEMA ................................................................ 79<br />
5.10.9.4 GALAXY-SCHEMA......................................................................... 80<br />
5.10.9.5 DAS UNIMU-SCHEMA.................................................................. 81<br />
6 DIE MODELLIERUNGSMETHODE AGGREGATION PATH<br />
ARRAY.........................................................................................83<br />
7 FORSCHUNGSSCHWERPUNKT UND ERGEBNISSE ................90<br />
7.1 DAS GRUNDPROBLEM UND DER LÖSUNGSANSATZ ............................. 90<br />
7.2 DIE VORGEHENSWEISE..................................................................... 91<br />
7.3 ABGRENZUNG DER PHASEN DER BETRACHTUNG................................ 92<br />
7.4 VERWANDTE ALGORITHMEN IM PROBLEMZUSAMMENHANG ............... 94<br />
7.4.1 KÜRZESTE UND LÄNGSTE WEGE ............................................................ 94<br />
7.4.1.1 BEGRIFFSBESTIMMUNGEN ........................................................... 94<br />
7.4.1.1.1 GRAPHEN...................................................................................... 94<br />
7.4.1.1.2 EINGANGS- UND AUSGANGSGRAD ............................................... 95<br />
7.4.1.1.3 WEG, ZYKLUS .............................................................................. 95<br />
7.4.1.1.4 KNOTEN- UND KANTENWERTE .................................................... 95<br />
7.4.1.1.5 KLASSIFIZIERUNG VON GRAPHEN................................................ 96<br />
- 6 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.4.1.2 KÜRZESTE WEGE VON EINEM KONTEN IM GRAPHEN ZU<br />
ALLEN ANDEREN ............................................................................................. 96<br />
7.4.1.2.1 ALGORITHMUS VON DIJKSTRA .................................................... 97<br />
7.4.1.2.2 ALGORITHMUS VON BELLMANN-FORD ..................................... 103<br />
7.4.1.2.3 KÜRZESTE WEGE FÜR EINEN AZYKLISCHEN GRAPHEN ........... 104<br />
7.4.1.3 KÜRZESTE WEGE ZWISCHEN ALLEN KONTEN IM GRAPHEN 106<br />
7.5 KOSTENBASIERENDE ABFRAGEBEARBEITUNG IN RELATIONALEN<br />
SYSTEMEN................................................................................................108<br />
7.6 DIE HEURISTIKEN..........................................................................116<br />
7.6.1 EINTEILUNG DER KOSTEN.................................................................... 116<br />
7.6.2 KOSTENSCHÄTZFUNKTION DER ABFRAGEPHASE................................ 117<br />
7.6.2.1 BEGRIFFSDEFINITIONEN............................................................. 117<br />
7.6.2.2 WERTEBEREICHE UND BEDINGUNGEN.................................... 118<br />
7.6.2.3 FUNKTION....................................................................................... 118<br />
7.6.2.4 BESCHREIBUNG DER KOSTENSCHÄTZFUNKTION.................. 118<br />
7.6.3 KOSTENSCHÄTZFUNKTIONEN DER MATERIALISIERUNGSPHASE........ 118<br />
7.6.3.1 BEGRIFFSDEFINITIONEN............................................................. 118<br />
7.6.3.2 WERTEBEREICHE UND BEDINGUNGEN.................................... 119<br />
7.6.3.3 FUNKTION....................................................................................... 119<br />
7.6.3.4 BESCHREIBUNG DER KOSTENSCHÄTZFUNKTION.................. 120<br />
7.6.4 GESAMTKOSTEN................................................................................... 120<br />
7.6.4.1 BEGRIFFSDEFINITIONEN............................................................. 120<br />
7.6.4.2 WERTEBEREICHE UND BEDINGUNGEN.................................... 121<br />
7.6.4.3 FUNKTION....................................................................................... 121<br />
7.6.5 ZUFÄLLIGE KOSTEN............................................................................. 121<br />
7.6.6 HEURISTIK VON ALEXANDER PROSSER ........................................... 123<br />
7.6.7 HEURISTIK VON THOMAS ACHS......................................................... 127<br />
7.6.7.1 PSEUDOCODE DER HEURISTIK.................................................. 127<br />
7.6.7.2 BESCHREIBUNG DER HEURISTIK............................................... 134<br />
- 7 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.6.7.3 DEMONSTRATIVES BEISPIEL....................................................... 134<br />
7.7 DIE DETERMINISTISCHE LÖSUNG....................................................147<br />
7.7.1 MATHEMATISCHE GRUNDLAGEN ........................................................ 147<br />
7.7.1.1 PERMUTATION ............................................................................... 147<br />
7.7.1.2 KOMBINATION................................................................................ 147<br />
7.7.2 DER ALGORITHMUS FÜR DIE PERMUTATION ...................................... 148<br />
7.7.3 DER ALGORITHMUS FÜR DIE KOMBINATION ...................................... 152<br />
7.7.4 DER ALGORITHMUS DER FUNKTION GETRIGHTORDER .................... 156<br />
7.7.5 DER ALGORITHMUS DER FUNKTION KOSTENFUERSETBERECHNEN. 161<br />
7.8 DIE ENTWICKLUNGSUMGEBUNG UND DIE APPLIKATION..................164<br />
7.8.1 AUSWAHL DER ENTWICKLUNGSUMGEBUNG ....................................... 164<br />
7.8.2 ENTWURF DER BENUTZERSCHNITTSTELLE......................................... 165<br />
7.8.2.1 DAS HAUPTMENU.......................................................................... 165<br />
7.8.2.2 DIE EINGABEMASKE (INPUT SCREEN) ...................................... 166<br />
7.8.2.3 DIE PRÄSENTATIONSMASKE (APA SCREEN) ............................. 167<br />
7.8.2.4 DIE AUSWAHLMASKE DER REQUIRED CUBES (SELECTION<br />
SCREEN) 168<br />
7.8.3 DATENMODELLIERUNG DER APPLIKATION......................................... 169<br />
7.8.3.1 AUSWAHL DER DATENBANK........................................................ 169<br />
7.8.3.2 SEMANTISCHE DATENMODELLIERUNG.................................... 170<br />
7.8.3.3 LOGISCHE DATENMODELLIERUNG........................................... 173<br />
7.8.3.4 PHYSISCHE DATENMODELLIERUNG ......................................... 176<br />
7.8.3.4.1 FORMALE SQL-ANWEISUNGEN LAUT SQL 99 ......................... 176<br />
7.8.3.4.2 MICROSOFT SQL SPEZIFISCHE SQL ANWEISUNGEN............... 178<br />
7.8.3.5 GENERIEREN DER CREATE TABLE ANWEISUNGEN IN DER<br />
SOFTWARE ...................................................................................................... 184<br />
7.8.3.5.1 DAS STAR-SCHEMA .................................................................... 184<br />
7.8.3.5.2 DAS FACT CONSTELLATION SCHEMA ....................................... 186<br />
7.8.3.5.3 BEISPIELHAFTES UMSETZEN DER TABLES DURCH DAS<br />
PROGRAMM .................................................................................................. 187<br />
- 8 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.8.3.5.3.1 DIE AUSGANGSPOSITION ........................................................ 187<br />
7.8.3.5.3.2 DIE SCRIPTS FÜR DAS STAR SCHEMA....................................... 189<br />
7.8.3.5.3.3 DIE SCRIPTS FÜR DAS FACT CONSTELLATION SCHEMA ............ 193<br />
7.9 ERGEBNISSE DER TESTS DER HEURISTIKEN .....................................200<br />
7.9.1 PROBLEME BEI TESTEN DER HEURISTIK............................................. 200<br />
7.9.2 GESAMTÜBERSICHT ÜBER DIE ERGEBNISSE........................................ 202<br />
7.9.3 DIE ERGEBNISSE IM DETAIL ................................................................ 204<br />
7.9.3.1 VORGABEN UND ERGEBNISSE TEST 1 ....................................... 204<br />
7.9.3.1.1 VORGABEN.................................................................................. 204<br />
7.9.3.1.2 LÖSUNG DER HEURISTIK............................................................ 204<br />
7.9.3.1.3 DETERMINISTISCHE LÖSUNG..................................................... 205<br />
7.9.3.1.4 VERGLEICH DER ERGEBNISSE ................................................... 205<br />
7.9.3.2 VORGABEN UND ERGEBNISSE TEST 2 ....................................... 205<br />
7.9.3.2.1 VORGABEN.................................................................................. 205<br />
7.9.3.2.2 LÖSUNG DER HEURISTIK............................................................ 206<br />
7.9.3.2.3 DETERMINISTISCHE LÖSUNG..................................................... 206<br />
7.9.3.2.4 VERGLEICH DER ERGEBNISSE ................................................... 207<br />
7.9.3.3 VORGABEN UND ERGEBNISSE TEST 3 ....................................... 207<br />
7.9.3.3.1 VORGABEN.................................................................................. 207<br />
7.9.3.3.2 LÖSUNG DER HEURISTIK............................................................ 207<br />
7.9.3.3.3 DETERMINISTISCHE LÖSUNG..................................................... 208<br />
7.9.3.3.4 VERGLEICH DER ERGEBNISSE ................................................... 208<br />
7.9.3.4 VORGABEN UND ERGEBNISSE TEST 4 ....................................... 209<br />
7.9.3.4.1 VORGABEN.................................................................................. 209<br />
7.9.3.4.2 LÖSUNG DER HEURISTIK............................................................ 209<br />
7.9.3.4.3 DETERMINISTISCHE LÖSUNG..................................................... 210<br />
7.9.3.4.4 VERGLEICH DER ERGEBNISSE ................................................... 210<br />
7.9.3.5 VORGABEN UND ERGEBNISSE TEST 5 ....................................... 211<br />
7.9.3.5.1 VORGABEN.................................................................................. 211<br />
- 9 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.5.2 LÖSUNG DER HEURISTIK............................................................ 211<br />
7.9.3.5.3 DETERMINISTISCHE LÖSUNG..................................................... 212<br />
7.9.3.5.4 VERGLEICH DER ERGEBNISSE ................................................... 212<br />
7.9.3.6 VORGABEN UND ERGEBNISSE TEST 6 ....................................... 213<br />
7.9.3.6.1 VORGABEN.................................................................................. 213<br />
7.9.3.6.2 LÖSUNG DER HEURISTIK............................................................ 213<br />
7.9.3.6.3 DETERMINISTISCHE LÖSUNG..................................................... 214<br />
7.9.3.6.4 VERGLEICH DER ERGEBNISSE ................................................... 214<br />
7.9.3.7 VORGABEN UND ERGEBNISSE TEST 7 ....................................... 215<br />
7.9.3.7.1 VORGABEN.................................................................................. 215<br />
7.9.3.7.2 LÖSUNG DER HEURISTIK............................................................ 215<br />
7.9.3.7.3 DETERMINISTISCHE LÖSUNG..................................................... 216<br />
7.9.3.7.4 VERGLEICH DER ERGEBNISSE ................................................... 216<br />
7.9.3.8 VORGABEN UND ERGEBNISSE TEST 8 ....................................... 217<br />
7.9.3.8.1 VORGABEN.................................................................................. 217<br />
7.9.3.8.2 LÖSUNG DER HEURISTIK............................................................ 217<br />
7.9.3.8.3 DETERMINISTISCHE LÖSUNG..................................................... 218<br />
7.9.3.8.4 VERGLEICH DER ERGEBNISSE ................................................... 218<br />
7.9.3.9 VORGABEN UND ERGEBNISSE TEST 9 ....................................... 219<br />
7.9.3.9.1 VORGABEN.................................................................................. 219<br />
7.9.3.9.2 LÖSUNG DER HEURISTIK............................................................ 219<br />
7.9.3.9.3 DETERMINISTISCHE LÖSUNG..................................................... 220<br />
7.9.3.9.4 VERGLEICH DER ERGEBNISSE ................................................... 220<br />
7.9.3.10 VORGABEN UND ERGEBNISSE TEST 10 ................................. 221<br />
7.9.3.10.1 VORGABEN................................................................................ 221<br />
7.9.3.10.2 LÖSUNG DER HEURISTIK.......................................................... 221<br />
7.9.3.10.3 DETERMINISTISCHE LÖSUNG................................................... 222<br />
7.9.3.10.4 VERGLEICH DER ERGEBNISSE ................................................. 222<br />
7.9.3.11 VORGABEN UND ERGEBNISSE TEST 11 ................................. 223<br />
- 10 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.11.1 VORGABEN................................................................................ 223<br />
7.9.3.11.2 LÖSUNG DER HEURISTIK.......................................................... 223<br />
7.9.3.11.3 DETERMINISTISCHE LÖSUNG................................................... 224<br />
7.9.3.11.4 VERGLEICH DER ERGEBNISSE ................................................. 224<br />
7.9.3.12 VORGABEN UND ERGEBNISSE TEST 12 ................................. 225<br />
7.9.3.12.1 VORGABEN................................................................................ 225<br />
7.9.3.12.2 LÖSUNG DER HEURISTIK.......................................................... 225<br />
7.9.3.12.3 DETERMINISTISCHE LÖSUNG................................................... 226<br />
7.9.3.12.4 VERGLEICH DER ERGEBNISSE ................................................. 226<br />
7.9.3.13 VORGABEN UND ERGEBNISSE TEST 13 ................................. 227<br />
7.9.3.13.1 VORGABEN................................................................................ 227<br />
7.9.3.13.2 LÖSUNG DER HEURISTIK.......................................................... 227<br />
7.9.3.13.3 DETERMINISTISCHE LÖSUNG................................................... 228<br />
7.9.3.13.4 VERGLEICH DER ERGEBNISSE ................................................. 228<br />
7.9.3.14 VORGABEN UND ERGEBNISSE TEST 14 ................................. 229<br />
7.9.3.14.1 VORGABEN................................................................................ 229<br />
7.9.3.14.2 LÖSUNG DER HEURISTIK.......................................................... 230<br />
7.9.3.14.3 DETERMINISTISCHE LÖSUNG................................................... 231<br />
7.9.3.14.4 VERGLEICH DER ERGEBNISSE ................................................. 231<br />
7.9.3.15 VORGABEN UND ERGEBNISSE TEST 15 ................................. 232<br />
7.9.3.15.1 VORGABEN................................................................................ 232<br />
7.9.3.15.2 LÖSUNG DER HEURISTIK.......................................................... 232<br />
7.9.3.15.3 DETERMINISTISCHE LÖSUNG................................................... 233<br />
7.9.3.15.4 VERGLEICH DER ERGEBNISSE ................................................. 233<br />
7.9.3.16 VORGABEN UND ERGEBNISSE TEST 16 ................................. 233<br />
7.9.3.16.1 VORGABEN................................................................................ 233<br />
7.9.3.16.2 LÖSUNG DER HEURISTIK.......................................................... 234<br />
7.9.3.16.3 DETERMINISTISCHE LÖSUNG................................................... 236<br />
7.9.3.16.4 VERGLEICH DER ERGEBNISSE ................................................. 237<br />
- 11 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.17 VORGABEN UND ERGEBNISSE TEST 17 ................................. 238<br />
7.9.3.17.1 VORGABEN................................................................................ 238<br />
7.9.3.17.2 LÖSUNG DER HEURISTIK.......................................................... 239<br />
7.9.3.17.3 DETERMINISTISCHE LÖSUNG................................................... 240<br />
7.9.3.17.4 VERGLEICH DER ERGEBNISSE ................................................. 240<br />
7.9.3.18 VORGABEN UND ERGEBNISSE TEST 18 ................................. 241<br />
7.9.3.18.1 VORGABEN................................................................................ 241<br />
7.9.3.18.2 LÖSUNG DER HEURISTIK.......................................................... 241<br />
7.9.3.18.3 DETERMINISTISCHE LÖSUNG................................................... 242<br />
7.9.3.18.4 VERGLEICH DER ERGEBNISSE ................................................. 242<br />
8 CONCLUSIO.........................................................................242<br />
9 LITERATUR .........................................................................244<br />
10 ABBILDUNGSVERZEICHNIS .............................................250<br />
11 TABELLENVERZEICHNIS .................................................254<br />
12 ANHANG...........................................................................255<br />
12.1 QUELLCODE DER ANWENDUNG...................................................255<br />
12.1.1 PROGRAMM QUELLCODE APAWIN ................................................... 255<br />
12.1.2 UNIT APA_ANALYSEUNIT.DFM ........................................................... 255<br />
12.1.3 UNIT APA_ANALYSEUNIT.PAS ............................................................ 256<br />
12.1.4 UNIT APA_APPLICATIONUNIT.DFM.................................................... 259<br />
12.1.5 UNIT APA_APPLICATIONUNIT.PAS ..................................................... 262<br />
12.1.6 UNIT APA_DIALOGUNIT.DFM .............................................................. 282<br />
12.1.7 ENDUNIT APA_DIALOGUNIT.PAS......................................................... 282<br />
12.1.8 UNIT APA_GRIDUNIT.DFM.................................................................. 283<br />
12.1.9 UNIT APA_GRIDUNIT.PAS ................................................................... 292<br />
12.1.10 UNIT APA_HELPUNIT.DFM.............................................................. 388<br />
12.1.11 UNIT APA_HELPUNIT.PAS............................................................... 389<br />
12.1.12 UNIT APA_INPUT_DIMENSIONUNIT.DFM ....................................... 390<br />
- 12 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
12.1.13 UNIT APA_INPUT_DIMENSIONUNIT.PAS......................................... 391<br />
12.1.14 UNIT APA_INPUT_HIERARCHYUNIT.DFM ...................................... 392<br />
12.1.15 UNIT APA_INPUT_HIERARCHYUNIT.PAS ....................................... 393<br />
12.1.16 UNIT APA_INPUT_REQBLOCKUNIT.DFM........................................ 395<br />
12.1.17 UNIT APA_INPUT_REQBLOCKUNIT.PAS......................................... 396<br />
12.1.18 UNIT APA_INPUT_SCREENUNIT.DFM ............................................. 397<br />
12.1.19 UNIT APA_INPUT_SCREENUNIT.PAS............................................... 401<br />
12.1.20 UNIT APA_KEYUNIT.DFM ............................................................... 412<br />
12.1.21 UNIT APA_KEYUNIT.PAS ................................................................ 413<br />
12.1.22 UNIT APA_OPTIONSUNIT.DFM........................................................ 414<br />
12.1.23 UNIT APA_OPTIONSUNIT.PAS ......................................................... 416<br />
12.1.24 UNIT APA_PARAMETERUNIT.DFM.................................................. 417<br />
12.1.25 UNIT APA_PARAMETERUNIT.PAS ................................................... 425<br />
12.1.26 UNIT APA_PROCESSUNIT.DFM........................................................ 434<br />
12.1.27 UNIT APA_PROCESSUNIT.PAS......................................................... 435<br />
12.1.28 UNIT APA_SCREENUNIT.DFM ......................................................... 437<br />
12.1.29 UNIT APA_SCREENUNIT.PAS........................................................... 438<br />
12.1.30 UNIT APA_SELECTIONUNIT.DFM.................................................... 440<br />
12.1.31 UNIT APA_SELECTIONUNIT.PAS ..................................................... 444<br />
12.1.32 UNIT APA_SHOW_COSTSUNIT.DFM ................................................ 458<br />
12.1.33 UNIT APA_SHOW_COSTSUNIT.PAS ................................................. 459<br />
12.1.34 UNIT APA_SQLUNIT.DFM................................................................ 462<br />
12.1.35 UNIT APA_SQLUNIT.PAS ................................................................. 463<br />
12.2 QUELLCODES DER HILFEDATEIEN...............................................464<br />
12.2.1 INDEX.HTM ........................................................................................... 464<br />
12.2.2 APA_GRID_SCREEN.HTM ................................................................... 465<br />
12.2.3 APA_INPUT_SCREEN.HTM .................................................................. 467<br />
12.2.4 APA_INSTALL.HTM ............................................................................. 469<br />
12.2.5 APA_MAINMENU.HTM ........................................................................ 470<br />
- 13 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
12.2.6 APA_SELECTION_SCREEN.HTM ......................................................... 471<br />
- 14 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
VORWORT UND DANKSAGUNGEN:<br />
Das Thema der Dissertation und das Verfassen einer Dissertation ist eine<br />
zeitaufwendige Tätigkeit. Durch die vielen Stunden, welche man in diese Arbeit<br />
investiert, wird unwillkürlich anderes vernachlässigt. Dies zieht sich vom beruflichen<br />
bis in den privaten Bereich. Das heißt, dass man auf seinem Wege bis hin zum<br />
Abschließen der Arbeit viele Menschen vernachlässigt. Ihnen gebührt Dank und<br />
Anerkennung, da sie somit einen Teil zu dieser Arbeit beigetragen haben.<br />
Dabei möchte ich mich besonders bei Professor Prosser bedanken. Wäre er nicht an<br />
mich herangetreten, hätte ich das Doktoratsstudium gar nicht begonnen. Zusätzlich<br />
danke ich ihm auch für seine Unterstützung und Hilfe beim Verfassen und für so<br />
manchen hilfreichen Tipp oder Denkanstoß. Weiters muss natürlich auch erwähnt<br />
werden, dass meine Arbeit auch unmittelbar auf die Arbeit von Professor Prosser und<br />
Frau Ossimitz aufbaut.<br />
Besonderer Dank gilt auch Professor Janko dafür, dass er die Zweitbeurteilung dieser<br />
Arbeit übernommen hat. Denn es ist bei solch speziellen Themen nicht sehr einfach<br />
einen Beurteiler zu finden.<br />
Der wichtigste Mann, welcher einen enormen Anteil am Gelingen dieser Arbeit hat, ist<br />
mein Großvater Georg ACHS, der mich jeden Tag auf das Neue motiviert hat und<br />
darauf aufmerksam gemacht hat, täglich ein neues Puzzlesteinchen zum Vollenden der<br />
Arbeit hinzuzufügen. Ohne ihn und seine täglichen Ermunterungen wäre diese Arbeit<br />
nie vollendet worden. Sehr großer Dank gilt auch meinen Eltern, Gerlinde und Hans<br />
Georg ACHS, welche mich beruflich entlasten konnten und mir zu jeder Zeit eine<br />
Stütze gewesen sind. Ein besonderer Dank an dieser Stelle speziell meiner Mutter für<br />
das fachmännische Korrekturlesen der Arbeit. Auch meine Großmütter, meine<br />
Schwester, meine Großtanten, weitere Verwandte und Freunde will ich erwähnen und<br />
mich zusätzlich entschuldigen, dass ich sie, auf Grund dieser Arbeit, des Öfteren<br />
versetzt und vernachlässigt habe. Ich werde mich bessern.<br />
Thomas ACHS, Gols im JUNI 2004<br />
- 15 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
1 EINFÜHRUNG<br />
1.1 ZIEL DER ARBEIT<br />
Das Planen und Entwickeln eines optimalen Data Warehouse-Systems ist ein Ansinnen<br />
vieler Wissenschaftler und Forscher aus unterschiedlichen Bereichen. Zahlreiche<br />
Publikationen wurden zu diesem Thema verfasst und in den letzten Jahren<br />
veröffentlicht. In dieser Literatur wird versucht eine Heuristik zu entwickeln, welche<br />
eine Lösung nahe am Optimum für das Materialisierungsproblem im Datawarehouse<br />
liefert. In der Vergangenheit wurde in zahlreichen Publikationen Annahmen, wie<br />
unbegrenzte Ressourcen oder rasche Zugriffszeit getroffen, welche in der realen Welt<br />
allerdings nicht vorhanden sind. Die Vision, welche hinter dieser Arbeit steckt, ist es,<br />
ein Instrument zu entwickeln, welches diese limitierenden Faktoren mitberücksichtigt,<br />
bzw. dieses versucht. Dabei hat sich insbesonders die Modellierungsmethode des<br />
Aggregation Path Arrays von Prosser und Ossimitz [vgl. Prosser/Ossimitz (2001)] als<br />
geeignet erwiesen, in diesem Problembereich einen Lösungsansatz zu finden. Vor allem<br />
ist diese Methode durch die einfache graphische Darstellungsfähigkeit besonders für<br />
informationstechnische Darstellung geeignet. Dabei ist es auch unerfahrenen<br />
Endbenutzer möglich, das Design eines Warehouses zu bewerkstelligen. Aus diesem<br />
Grund ist die Methode auch für Schulungs- und Ausbildungszwecke besonders<br />
geeignet.<br />
Die kostenminimale physische Bereitstellung der wichtigen Informationen für die<br />
Entscheidungsträger in Unternehmen stellt das Ziel dieser Arbeit dar. Dabei ist ein<br />
Optimierungsproblem zu lösen, welches limitierende Zeit- und Speicherressourcen bei<br />
gleichzeitigem Berücksichtigen wichtiger Information beachtet. Leider ist diese<br />
Information nicht immer als homogen anzusehen. Es gibt beispielsweise wichtige<br />
Information, welche für das Überleben einer Organisation notwendig ist und<br />
Information, welche wichtig, aber nicht ständig verfügbar sein muss. Der Versuch einen<br />
Lösungsansatz für diese Problematik zu finden, stellt das Herzstück meiner Arbeit dar.<br />
1.2 VORGEHENSWEISE<br />
Der Kern der Arbeit stellt das praktische Darstellen des Aggregation Path Arrays (APA)<br />
dar. Dabei wird eine Software-Applikation (Quellcode im Anhang) ausprogrammiert,<br />
welche ein benutzerunterstützendes Design des Data Warehouses ermöglicht. Zusätzlich<br />
soll nach der Eingabe der benötigten Informationen, welche sich durch so genannte<br />
„Required cubes“ manifestieren, der Benutzer bei der Auswahl der zu<br />
materialisierenden und somit physisch in der Datenbank lagernden Information<br />
- 16 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
unterstützt werden. Dies soll, da die Optimierung ein sehr komplexes Lösungsproblem<br />
darstellen kann, heuristisch gelöst werden. Im Vergleich dazu werden Algorithmen<br />
ausgetestet, welche zwar eine ideale Lösung liefern, aber für komplexe<br />
Problemstellungen sehr lange Berechnungszeiten erfordern. Abschließend werden die<br />
Ergebnisse verglichen, um eine Bewertung des heuristischen Ansatzes zu treffen.<br />
Im Vorfeld wird relevante Literatur zum Konnex aufbereitet, welche die Grundlage zum<br />
Verstehen der Zusammenhänge darstellt.<br />
2 DATENMODELLIERUNG<br />
Für die Modellierung von Daten ist es zweckmäßig, sich die verschiedenen<br />
Betrachtungsebenen für Daten und Informationen zu veranschaulichen. Dabei versucht<br />
man eine betriebswirtschaftliche Problemstellung in mehreren Stufen abzubilden.<br />
Diese sind das<br />
• Fachkonzept (semantisches Datenmodell): Auf dieser Ebene befindet sich die<br />
ER-Diagramm-Ebene.<br />
• DV-Konzept (logisches Datenmodell): Dies beschreibt die Daten eines<br />
Informationssystems auf der Ebene der Datenbanken.<br />
• Technische Implementierung (physisches Datenmodell): Auf dieser Ebene<br />
betrachtet man die reale Ausbildung der Datenbank, wie die SQL-Anweisungen.<br />
Wie durch den hierarchischen Aufbau angedeutet werde ich mich bei meinen<br />
Ausführungen vom semantischen Modell bis zur endgültigen Implementierung der<br />
Datenbank und der Tables (Tabellen) vortasten.<br />
2.1 SEMANTISCHES DATENMODELL<br />
Ein vielfach bewährtes Werkzeug zur Erstellung von relationalen Datenbanken ist das<br />
Entity Relationship Modell, kurz ER-Modell genannt. Dieses Modell wurde von P.<br />
Chen im Jahre 1976 vorgestellt. Das ER-Modell verhindert Redundanzen bis auf<br />
Fremdschlüssel auch relationenübergreifend. [vgl. Schicker (1999) S.136f ]<br />
Um mit dem ER-Modell nach Chen arbeiten zu können sind im Vorfeld eine Reihe von<br />
Begriffen zu klären und auszuformulieren. Diese Vokabel werden bei der Modellierung<br />
verwendet und können als Bausteine für das ER-Diagramm angesehen werden. Wir<br />
werden das ER-Modell für unsere Arbeit einsetzen. Deshalb soll es auch hier im Detail<br />
erläutert werden. Alternative Modellierungsmethoden sind insbesondere das „ER-<br />
Modell nach der Notation „Barker“ oder die „Unified Modeling Language“ [vgl. Cordts<br />
(2002) S. 35ff]. Für detaillierte weiterführende Ausführungen über semantische<br />
- 17 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Datenmodellierung verweise ich auf Baldi (1999) S. 76ff, Fischer et al. (2000) S. 105ff,<br />
Janko (1998) S. 335ff, Kemper (1999), S. 33ff und Meier (2001) S. 16ff.<br />
2.1.1 ENTITÄTEN (ENTITIES)<br />
Wie der Name schon sagt, ist der grundlegendste Baustein des ER-Diagramms die<br />
Entität (Gegenstand). Entitäten sind wohlunterscheidbare physisch oder gedanklich<br />
existierende Konzepte der zu modellierenden Welt. Entitäten werden im Diagramm<br />
durch Rechtecke dargestellt.<br />
Abbildung 1: Symbol für Entitätstyp<br />
Man unterscheidet folgende Arten von Entitätstypen:<br />
Super- und Subentitätstypen:<br />
Superentitätstypen fassen gemeinsame Attributsmengen von Subentitätstypen<br />
zusammen. Offensichtlich ist der Entitätstyp „Auftrag“ ein Superentitätstyp, da er<br />
Attribute der Subentitätstypen „Kundenauftrag“, „Fertigungsauftrag“,<br />
„Beschaffungsauftrag“ usw. zusammenfasst. Siehe dazu auch Entitätsmengen 2.1.2.<br />
Fundamentale Entitätstypen:<br />
Existieren um ihrer selbst willen. Die Entitäten fundamentaler Entitätstypen<br />
repräsentieren eindeutige Objekte der realen Welt. Beispiele für solche Entitätstypen<br />
sind „Geschäftspartner“ oder „Artikel“.<br />
Entitäten assoziativer Entitätstypen:<br />
Drücken einen fachlichen Zusammenhang zwischen fundamentalen Entitäten aus und<br />
haben eigene Attribute. Sie haben eine Art „Zwitterfunktion“, da sie auch als<br />
Beziehungstypen angesehen werden können. Ein Beispiel für einen solchen Entitätstyp<br />
ist „Auftragsposition“, der auch als Beziehungstyp zwischen „Auftrag“ und „Artikel“<br />
angesehen werden kann.<br />
2.1.2 ENTITÄTSMENGEN (ENTITY SETS)<br />
Ähnliche Entitäten können zu Entitätsmengen zusammengefasst werden. So könnten die<br />
Subentitäten Kunde, Lieferant und Bank unter Superentität Geschäftspartner<br />
zusammengefasst werden.<br />
- 18 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 2: Super- und Subentitätstypen mit „is a“ Operator<br />
[Quelle: Rautenstrauch/Schulze (2003) S. 237]<br />
Für die Modellierung von Super- und Subentitätstypen wird der „is a“- Operator als<br />
Dreieck eingeführt. Auf der Spitze des Dreiecks wird der Superentitätstyp und auch der<br />
Unterseite werden die Subentitätstypen notiert. Die Erzeugung von Superentitätstypen<br />
durch Zusammenfassen gemeinsamer Attributsmengen verschiedener Entitätstypen<br />
wird Generalisierung und das „Herausziehen“ von Subentitätstypen mit disjunkten<br />
eigenen Attributsmengen wird Spezialisierung genannt.<br />
2.1.3 ATTRIBUTE UND SCHLÜSSEL<br />
Entitätstypen werden durch Attribute, d.h. Eigenschaften bzw. Merkmale,<br />
charakterisiert. Eine bestimmte Entität ist durch spezifische Werte für die Attribute<br />
gekennzeichnet.<br />
Ein Attributstyp Kunde besitzt beispielsweise die Attribute Name, Straße, Wohnort und<br />
Kundennr. In der graphischen Darstellung werden Entitäten durch Ellipsen dargestellt.<br />
Abbildung 3: Entitätsmenge mit Attributen<br />
- 19 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Bestimmte Attribute werden benutzt, um Entitäten voneinander zu unterscheiden.<br />
Hierfür eignen sich aber nur solche Attribute oder Attributkombinationen, die<br />
Eindeutigkeit gewährleisten. Solche Attribute oder Attributkombinationen werden auch<br />
als Schlüsselkandidaten bezeichnet, da sie sich für Primärschlüssel in den späteren<br />
Tabellen nahezu anbieten. Primärschlüssel werden in ER-Diagrammen unterstrichen<br />
dargestellt.<br />
Jedes Attribut hat einen Wertebereich (Datentyp). So kann ein Attribut beispielsweise<br />
einen Zeitpunkt (Geburtsdatum), eine Zahl (Mahnstufe), einen Text (Name) usw.<br />
bezeichnen. Man kann einfache Attribute, die aus einer einzelnen Komponente mit einer<br />
unabhängigen Existenz bestehen (wie Geschlecht oder Gehalt) und zusammengesetzte<br />
Attribute, die aus mehreren Komponenten zusammengesetzt sind, die wiederum eine<br />
eigene Existenz besitzen, unterteilen (z.B. Das Attribut Adresse besteht aus Strasse,<br />
Postcode und Ort). [vgl. Connolly et al. (2002) S 186f]<br />
2.1.4 BEZIEHUNGEN (RELATIONSHIPS)<br />
Eine Beziehung (auch als Relation bezeichnet) ist eine Verknüpfung zwischen<br />
verschiedenen Entitäten. So kann z.b. die Entität „Kunden“ mit der Entität „Konto“ in<br />
Beziehung stehen, indem der Kunde ein Konto besitzen kann.<br />
Anhaltspunkt dafür, was als Entitätstyp und was als Beziehungstyp bezeichnet werden<br />
kann, ist die Verwendung von Substantiven bzw. von Verben. Entitätstypen werden in<br />
der Regel mit Substantiven; Beziehungstypen in der Regel mit Verben bezeichnet. [vgl.<br />
Heinrich (2001), S. 246]<br />
Normalerweise verknüpft man jeweils zwei Entitäten über eine Relation. In diesem Fall<br />
spricht man von einer zweiwertigen oder binären Relation.<br />
Abbildung 4: Einfaches Symbol eines Beziehungstyps für einfache Darstellbarkeit<br />
Abbildung 5: Formal richtiges Beziehungssymbol der ER-Modell Konvention<br />
- 20 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Die Bedeutung, die einem Entitätstyp in einer Beziehung zukommt, nennt man auch<br />
seine Rolle. Die Rolle des Entitätstypen „Kunde“ im obigen Beispiel ist<br />
„Kontoinhaber“. Wenn ein Entitätstyp mehrere Beziehungen eingeht, kann er auch<br />
mehrere Rollen einnehmen.<br />
2.1.5 KARDINALITÄTEN VON BEZIEHUNGEN<br />
Die semantische Aussagekraft eines Datenmodells bezüglich der Abbildung der<br />
betrieblichen Realität kann durch die Angabe der Kardialität eines Beziehungstyps<br />
gesteigert werden. Die Kardialität ist eine quantitative Spezifikation für die Menge der<br />
auftretenden Beziehungen. Beziehungen kann man grundsätzlich in Kann-Beziehungen<br />
und Muss-Beziehungen einteilen. Bei einer Kann-Beziehung müssen nicht alle Objekte<br />
eines Objektsatzes durch die Beziehung angesprochen werden. Dadurch muss nicht<br />
jeder Artikel im Lager gleichzeitig als Position in einer Bestellung auftauchen. Bei einer<br />
Muss-Beziehung ist dies aber sehr wohl der Fall. So muss z.b. jeder Mitarbeiter einer<br />
Unternehmung einer Abteilung zugeordnet werden. [vgl. Morcinek (2002) S. 218f]<br />
Grad<br />
Ausprägung<br />
"Muss" "Kann"<br />
Beziehung Beziehung<br />
1 zu 1 [1,1] [0,1]<br />
1 zu N [1,*] [0,*]<br />
Tabelle 1: Kombinationen von Grad und Ausprägung<br />
Grundsätzlich lassen sich folgende Kardinalitäten unterscheiden:<br />
2.1.5.1 1-1 BEZIEHUNGEN<br />
Einer Entität wird genau eine Entität zugeordnet. Beispiel: Ein Mitarbeiter hat genau<br />
einen Hauptwohnsitz. „Diese Beziehungen sind in der Realität eher selten anzutreffen,<br />
da Entitäten zwischen denen eine solche Beziehung besteht, theoretisch in einer Entität<br />
zusammengefasst werden können“ [vgl. Rautenbach/ Schulze (2003) S. 131] .<br />
Abbildung 6: 1:1 Beziehung zwischen Kunde und Hauptwohnsitz<br />
- 21 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
2.1.5.2 1-N BEZIEHUNGEN<br />
Einer Entität werden mehrere oder eine Entität zugeordnet. Beispiel: In einer Abteilung<br />
können mehrere Mitarbeiter arbeiten.<br />
Abbildung 7: 1:n Beziehung zwischen Abteilung und Mitarbeiter<br />
2.1.5.3 M-N BEZIEHUNGEN<br />
Mehrere Entitäten werden mehreren anderen Entitäten zugeordnet. Beispiel: Ein<br />
Mitarbeiter bearbeitet mehrere Projekte. Ein Projekt wird von mehreren Mitarbeitern<br />
bearbeitet.<br />
Abbildung 8: m:n Beziehung zwischen Mitarbeiter und Projekt<br />
2.1.5.4 DIE REKURSIVE BEZIEHUNG<br />
Eine rekursive Beziehung ist eine Beziehung von Entitäten des gleichen Typs.<br />
Standardbeispiel ist die Beziehung „ist Vorgesetzter von“ eines Entitätstyps<br />
„Mitarbeiter“. Zu beachten ist hier auch die alternative Darstellungsmöglichkeit von<br />
Beziehungen durch eine Raute (im Unterschied zu der in Abbildung 6 verwendeten<br />
einfachen Darstellung).<br />
- 22 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 9: Rekursiver Beziehungstyp [Quelle: Rautenstrauch/Schulze (2003) S. 237]<br />
2.2 LOGISCHES DATENMODELL<br />
2.2.1 ALLGEMEINES<br />
Ein logisches Modell beschreibt die Daten eines Informationssystems auf der Ebene des<br />
DV-Konzepts. Unter den logischen Datenmodellen spielen vor allem vier Modelle eine<br />
Rolle:<br />
• Hierarchisches Datenmodell<br />
• Netzwerkdatenmodell<br />
• Relationales Datenmodell<br />
• Objektorientiertes Datenmodell<br />
• Objektrationonales Datenmodell<br />
Das in der Praxis wichtigste Datenmodell ist das „Relationale Modell“. Dieses<br />
werde ich auch als Basis für meine Datenmodellierung der Applikation verwenden,<br />
da mit Microsoft SQL als Datenbank für unsere Anwendung und das<br />
Datawarehouse eine relationale Datenbank gewählt wurde.<br />
- 23 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
2.2.2 DATENMODELLE<br />
2.2.2.1 HIERARCHISCHES DATENMODELL<br />
Das hierarchische Datenbankmodell basiert auf der mathematischen Baumstruktur.<br />
Wenn wir die einzelnen Dateien einer hierarchischen Datenbank als Knoten bezeichnen,<br />
so gelten folgende Vereinbarungen: Wie bei Verzeichnisstrukturen der meisten<br />
Betriebssysteme gibt es eine Wurzel. Dieser Knoten hat keinen Vorgänger und leitet<br />
alle anderen ab. Hat ein Knoten keinen Nachfolger wird er als Blatt bezeichnet.<br />
Abbildung 10: Firmenhierarchie<br />
- 24 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
Vorteile:<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
• Einfacher Aufbau<br />
• Sehr kurze Zugriffszeiten<br />
• Minimale Redundanz<br />
Nachteile:<br />
• Strukturveränderungen kaum möglich<br />
• Komplexe Programmierung<br />
2.2.2.2 NETZWERKDATENMODELL<br />
Das Netzwerkmodell beruht wie das hierarchische Modell auf der Graphentheorie,<br />
allerdings gibt es keine hierarchische Struktur und jeder Knoten kann mit jedem Knoten<br />
verbunden sein. Analog zur Abbildung 10 könnte also ein Arbeiter auch Mitglied in<br />
zwei Abteilungen sein.<br />
Vorteile:<br />
• Kurze Zugriffszeiten<br />
• Geringe Redundanz<br />
Nachteile:<br />
• Strukturveränderungen nicht einfach<br />
• Relativ komplexe Programmierung<br />
2.2.2.3 RELATIONALES DATENMODELL<br />
Das relationale Modell, das von Codd entwickelt wurde, basiert auf einer<br />
mathematischen Grundlage, der Relationenalgebra. Eine relationale Datenbank besteht<br />
ausschließlich aus Tabellen. Ein Zugriff erfolgt immer über diese Tabellen. Die<br />
Zusammenhänge zwischen den Tabellen werden über Beziehungen hergestellt. Diese<br />
Beziehungen werden über Primär- und Fremdschlüssel abgebildet.<br />
Das relationale Datenmodell ist tupelorientiert, die Information wird durch Relationen<br />
repräsentiert. Eine Relation ( 1, 2,...,<br />
n ) A A A R ist eine bekannte Menge von n-Tupeln,<br />
wobei n-Tupel eine Anordung von n atomaren, das heißt einfachen (nicht weiter<br />
zerlegbaren) Attributen (attributes) n A A A ,..., , 1 2 ist. [vgl. Schneider/Weber (2000) S. 471]<br />
- 25 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
Vorteile:<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
• Leichte Änderbarkeit des Datenbankaufbaus<br />
• Mathematisch fundiert<br />
• Leicht programmierbar und verwaltbar<br />
Nachteile:<br />
• Häufig viele Ein-/Ausgaben notwendig<br />
• Erfordert eine hohe Rechnerleistung<br />
• Erzeugt Redundanz<br />
• Komplizierte Objekte müssen erst in viele Tabellen zerlegt und beim Abfragen<br />
wiederum mühevoll rekonstruiert werden.<br />
Das relationale Modell ist das in der Praxis am häufigsten vorkommende Modell.<br />
Relationale Datenbanken sind die wichtigsten Datenbankanwendungen in der heutigen<br />
Zeit. Aus diesem Grund werde ich im Kapitel, das sich mit SQL beschäftigt im<br />
speziellen auf die Grundlagen des relationalen Datenmodells und der Relationenalgebra<br />
eingehen.<br />
2.2.2.4 OBJEKTORIENTIERTES DATENMODELL<br />
Eine objektorientierte Datenbank besteht ausschließlich auf Objekten. Ein Objekt ist<br />
entweder ein realer Gegenstand oder ganz allgemein ein abstrakter Gegenstand. Da<br />
viele Objekte auch in Tabellenform gespeichert werden können, werden<br />
objektorientierte Datenbanken häufig als eine Erweiterung relationaler Datenbanken<br />
angesehen. Dies trifft aber nur teilweise zu. Der Haupteinsatz von Objektorientierten<br />
Datenbankmanagementsystemen liegt in der Bereitstellung von Datenbankeigenschaften<br />
für objektorientierte Anwendungen, insbesondere für solche, die durch die traditionellen<br />
Datenmodelle und –systeme nur unzureichend unterstützt wurden. Beispiele für solche<br />
Anwendungsgebiete sind Entwurfsanwendungen (CAD, CASE), Geo-<br />
Informationssysteme (GIS), wissenschaftliche Anwendungen und Gebäudetechnik<br />
(Facility Management). Ein signifikantes Eindringen in die traditionellen<br />
Anwendungsbereiche relationaler Systeme ist ihnen jedoch nicht gelungen. [vgl. Geppert<br />
(2002) S. 30f]<br />
- 26 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
Vorteile:<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
• Objektorientierter Aufbau<br />
• Universell einsetzbar<br />
• Noch relativ einfach programmierbar und verwaltbar<br />
• (teilweise) kompatibel zu relationalen Datenbanken<br />
Nachteile:<br />
• relativ viele Ein-/Ausgaben notwendig<br />
• erfordert eine relativ hohe Rechenleistung<br />
• teilweise recht komplexer Aufbau<br />
2.2.2.5 OBJEKTRELATIONALES DATENMODELL<br />
Das objektrelationale Datenmodell steht als hybride Konstruktion zwischen dem<br />
relationalen und dem Objektdatenmodell. Das relationale Datenmodell wird dabei um<br />
folgende Elemente des Objektdatenmodells erweitert:<br />
Strukturierte Objekte:<br />
Aus den vorhandenen Datentypen können komplexere (nicht atomare) Strukturen<br />
definiert werden.<br />
Untertypen:<br />
Aus existierenden Typen können durch Spezialisierung neue gebildet werden<br />
(Untertypen). Diese erben alle Charakteristika des Obertyps.<br />
Erweitertes und erweiterbares Typsystem:<br />
Erweiterungen des relationalen Datenmodells um neue Typen (z.b. für<br />
Multimediadateien). Das Typsystem kann durch selbst definierte Typen erweitert<br />
werden.<br />
Referenzen:<br />
Zwischen den Datenelementen (d.h. Tupeln) können Beziehungen definiert werden, die<br />
nicht über Fremdschlüsselbeziehungen abgedeckt werden.<br />
[vgl. Schneider/Werner (2000) S. 475f]<br />
2.2.3 ÜBERFÜHRUNG DES ER-MODELLS INS RELATIONALE MODELL<br />
Auf der Erfahrung ergibt sich eine bestimmte Vorgehensweise beim Umsetzen des ER-<br />
Modells ins relationale Modell. Für die Umsetzung bestehen aber Freiheitsgrade und<br />
- 27 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Gestaltungsmöglichkeiten bei der Wahl der Relationen und ihrer Attribute. Das heißt<br />
die Umsetzung kann auch weit von diesen „Standardregeln“ der Umsetzung abweichen.<br />
Häufig wird für jeden Entitätstyp zunächst eine eigene Tabelle angelegt. Beziehungen<br />
werden dadurch abgebildet, dass in einer Tabelle ein Verweis auf einen Eintrag in einer<br />
anderen Tabelle eingefügt wird. Enthält eine Tabelle in einem Attribut oder einer<br />
Attributkombination einen Verweis auf eine andere Tabelle, so werden diese Attribute<br />
auch Fremdschlüssel (foreign key oder Sekundärschlüssel) genannt, da sie einen<br />
Verweis auf den Primärschlüssel einer anderen Relation darstellen.<br />
Jeder Wert eines Fremdschlüssels sollte auch als Wert im Primärschlüssel einer anderen<br />
Relation vorkommen. Diese Eigenschaft eines Relationenmodells bezeichnet man auch<br />
als referenzielle Integrität.<br />
- 28 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Die einzelnen Beziehungstypen werden üblicherweise im Relationenmodell wie folgt<br />
behandelt:<br />
2.2.3.1 DIE UMSETZUNG DER 1:1 BEZIEHUNG<br />
Bei einer 1:1 Beziehung wird eine beliebige der beiden für die Entitätstypen erstellten<br />
Tabellen um die Attributsspalte(n) des Primärschlüssels der anderen Tabelle ergänzt.<br />
Dabei muss jedoch überdacht werden, ob es sich bei dieser 1:1 Beziehung tatsächlich<br />
um zwei Entitäten handelt oder ob diese Entitäten eigentlich dasselbe Objekt<br />
verkörpern.[vgl. Connolly et al. (2002) S. 279]<br />
Abbildung 11: Beispielhafte Umsetzung einer 1:1 Beziehung in das Realtionenmodell in der<br />
vereinfachten Darstellung der Beziehung [Quelle: Baldi (1999), S. 84 ]<br />
- 29 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
2.2.3.2 DIE UMSETZUNG DER 1:N BEZIEHUNG<br />
Bei einer 1:n Beziehung wird die Tabelle der „n-Seite“ um die Attributsspalten des<br />
Primärschlüssels der anderen Tabelle erweitert.<br />
Abbildung 12: Beispielhafte Umsetzung einer 1:n Beziehung in das Relationenmodell in der<br />
vereinfachten Darstellung der Beziehung [Quelle: Baldi (1999), S. 84]<br />
2.2.3.3 DIE UMSETZUNG DER M:N BEZIEHUNG<br />
Bei einer m:n Beziehung wird eine zusätzliche Tabelle eingeführt, die als Attribute die<br />
Primärschlüsselattribute beider Entitätstypen erhält. Der Primärschlüssel dieser neuen<br />
Relation ergibt sich aus der Kombination der beiden Ursprungsprimärschlüssel.<br />
- 30 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 13: Beispielhafte Umsetzung einer m:n Beziehung in das Relationenmodell in der<br />
vereinfachten Darstellung der Beziehung [Quelle: Baldi (1999), S. 84 ]<br />
2.2.3.4 DIE UMSETZUNG EINER REKURSIVEN BEZIEHUNG<br />
Eine rekursive Beziehung wird analog zu einer 1:1 oder 1:n Beziehung umgesetzt. Die<br />
einzige Unterscheidung zwischen den oben angeführten Varianten ist, dass bei der<br />
rekursiven Beziehung die Zeiger auf die gleiche Tabelle zeigen. Deshalb funktioniert<br />
die Generierung dieser Tabelle analog.<br />
2.3 PHYSISCHES DATENMODELL<br />
Das physische Datenmodell beschreibt die Daten des Informationssystems auf der<br />
Ebene der technischen Implementierung. Das physische Datenmodell bezieht sich auf<br />
eine konkrete Datenbank und die Tables, welche real physisch in der Datenbank durch<br />
„CREATE TABLE“ Anweisungen erzeugt werden. Diese SQL-Anweisungen werden<br />
beispielhaft im Kapitel 7.8.3.4 erläutert.<br />
- 31 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
3 SQL UND DATENBANKEN<br />
3.1 DATENBANKEN<br />
3.1.1 ENTWICKLUNGSGESCHICHTE DER DATENBANKSYSTEME<br />
Im Laufe der Jahrzehnte wurde eine ganze Reihe von Konzepten entwickelt, die<br />
Datenbestände möglichst sicher, effizient und eventuell benutzerfreundlich verwalten<br />
können. Die Kernidee war Daten und Anwendungsprogramme zu trennen.<br />
Im Jahre 1959 entwickelten Techniker der Firma IBM das Ramac-System, das man<br />
vielleicht als frühen Vorläufer nachfolgender Datenbanksysteme bezeichnen darf. Mit<br />
diesem System wird erstmalig der nichtsequentielle Datenzugriff verwirklicht. Ein<br />
echter theoretischer Ansatz zur Datenbankverwaltung wird aber erst Anfang der<br />
Sechziger Jahre entwickelt. Der Mathematiker Bachmann entwirft und veröffentlicht in<br />
den Jahren 1961 bis 1964 Datenstrukturdiagramme; er formuliert außerdem<br />
Beziehungen zwischen den Daten, der Begriff der Beziehungstypen (sets) wird bereits<br />
hier geprägt.<br />
Dies ist die Grundlage für das von der Codasyl-Gruppe (Vereinigung der wichtigsten<br />
amerikanischen Computerhersteller und Computeranwender) im Jahre 1971<br />
verabschiedete Netzwerk Datenmodell. 1970 stellt E. Codd das relationale<br />
Datenbankmodell vor. Im Jahre 1976 veröffentlichte Peter S. Chen zum Thema<br />
Datenbankentwurf das Entity-Realtionsship Prinzip. Der entscheidende Schritt für die<br />
relationale Datenbankwelt war im Jahre 1973 die Entwicklung des Systems R von IBM.<br />
Dieses Datenbanksystem beinhaltete eine Anfragesprache namens SEQUEL, die im<br />
Laufe der Projektentwicklung in SQL umbenannt wurde, mit welcher wir uns auch in<br />
dieser Arbeit im Detail befassen wollen.<br />
3.1.2 BEGRIFFSDEFINITIONEN<br />
Die Begriffe Datenbank, Dateisystem, Datei usw. werden heute oft sehr sorglos und<br />
ohne begriffliche Abgrenzung verwendet. Um diesem Abhilfe zu schaffen will ich diese<br />
Begriffe hiermit im Vorfeld entsprechend definieren.<br />
Datei<br />
Eine Datei ist ein Datenbestand, der unter einem Dateinamen im Allgemeinen auf einem<br />
externen Datenträger gespeichert ist. Dieser Datenbestand kann auch als Strom von Bits<br />
interpretiert werden. Eine Datei hat immer einen Namen, um sie von anderen Dateien<br />
unterscheiden zu können. [vgl. Rautenstrauch et al. (2003) S. 99]<br />
- 32 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Daten<br />
Daten sind Informationen, die in digitaler Form auf Softwaresystem abgespeichert<br />
wurden. Daten können unformatiert (Text) oder formatiert sein.<br />
Datenbank Management System (DBMS)<br />
“Das DBMS (deutsch: Datenbankverwaltungssystem) ist eine spezielle Software, mit<br />
der größere, gemeinsame Datenbestände (Datenbank) aufgebaut, manipuliert und<br />
kontrolliert werden können“ [vgl. Fischer et al. (2000), S. 110]. Somit ist das DBMS die<br />
Gesamtheit aller Programme zur Erzeugung, Verwaltung und Manipulation der Daten<br />
[vgl. Schneider/Werner (2000) S. 469].<br />
Datenbank<br />
Eine Datenbank ist eine Sammlung von Daten, die untereinander in einer logischen<br />
Beziehung stehen und von einem eigenen Datenbankverwaltungssystem (DBMS)<br />
verwaltet werden. Kurz formuliert ein Datenbanksystem besteht aus Daten und einem<br />
Datenbankmanagementsystem. [vgl. Schicker (1999), S. 46]<br />
3.1.3 ANFORDERUNGEN EINES DATENBANKSYSTEMS<br />
Anforderungen an ein Datenbanksystem sind:<br />
Sammlung logisch verbundener Daten:<br />
Da Daten auf mehrere Dateien verteilt sind, muss das Datenbanksystem diese Dateien<br />
zusammenfügen, um die Information zu gewinnen.<br />
Speicherung der Daten mit möglichst wenig oder keiner Redundanz:<br />
Redundanz ist das mehrfache Speichern ein und der selben Information. Dies kann bei<br />
Änderungen zu Differenzen führen und sollte vermieden werden. Deswegen sollte das<br />
Datenbankverwaltungssystem die nicht vermeidbaren redundanten Daten automatisch<br />
anpassen.<br />
Abfragemöglichkeit und Änderbarkeit der Daten<br />
Diese selbstverständliche Forderung schließt ein, dass das Abfragen und Ändern der<br />
Daten entsprechend schnell ausgeführt wird.<br />
Logische Unabhängigkeit der Daten von ihrer physischen Struktur:<br />
Es genügt nicht, dass die Datenbank für die optimale Speicherung der Daten sorgt, der<br />
Benutzer will darüber hinaus nicht einmal wissen, wie die Daten physisch abgespeichert<br />
sind.<br />
Zugriffsschutz:<br />
Betriebssysteme kennen nur den Schutz von Dateien, nicht den Schutz von einzelnen<br />
Daten innerhalb der Datei. Dieser interne Schutz ist aber bei sensiblen Daten, wie den<br />
Personaldaten erforderlich. Zusätzlich ergibt sich die Entwicklung verschiedener<br />
- 33 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Sichten (Views) der Benutzer abhängig von den Rechten, welche diese besitzen [vgl.<br />
Schneider/Werner (2000) S. 470].<br />
Integrität:<br />
Integrität kommt von INTEGER und bedeutet hier, dass alle gespeicherten Daten<br />
korrekt sein müssen.<br />
Mehrfachzugriff:<br />
Auf die Forderung nach Datenzugriffen von mehreren Rechnern oder Terminals aus<br />
kann in der Regel heute nicht mehr verzichtet werden.<br />
Zuverlässigkeit:<br />
Das bedeutet Sicherheit vor unerlaubten Zugriffen.<br />
Ausfallssicherheit:<br />
Bedeutet Sicherheit der Daten in allen nur erdenklichen Fällen, wie Rechnerausfall<br />
oder Zerstörung durch Feuer.<br />
Kontrolle:<br />
Die Datenbank muss ständig Angaben über ihren momentanen Zustand machen können.<br />
Diese Angaben sind z.B. Anzahl der Benutzer, Auslastung der Festplatten oder<br />
Auslastung des DBMS.<br />
Die Anforderungen an ein Datenbanksystem können zum Teil auch als die Vorteile<br />
eines Datenbanksystems interpretiert werden. Tatsache ist, das der Einsatz von<br />
Datenbanksystemen einen enormen Leistungssprung in der Softwareentwicklung<br />
gebracht hat.<br />
3.2 SQL ALS STANDARDISIERTE DATENBANKSPRACHE<br />
3.2.1 GESCHICHTLICHES<br />
Mit SQL steht eine Sprache zur Verfügung, mit der alle Funktionen auf relationalen<br />
Datenbanken ausgeführt werden können. Basis von SQL ist die Relationenalgebra, die<br />
eine mathematisch vollständige und konsistente Beschreibung sämtlicher auf<br />
relationalen Datenbanken anwendbaren Operationen bietet.<br />
Seit 1974 IBM mit SEQUEL die erste relationale Datenbanksprache auf den Markt<br />
brachte, hat sich die in den Folgejahren daraus entwickelte Sprache SQL weiter<br />
verbreitet, um sich schließlich ab 1982 als ANSI-Standard allgemein durchzusetzen.<br />
Seit dem ist eine ständige Weiterentwicklung im Fluss. 1987 wurde der ANSI-Standard<br />
SQL-1 geschaffen und 1989 der verbesserte ANSI-Standard SQL-2. Die ISO schloss<br />
sich dieser Standardisierung an, und auch in der deutschen Norm DN66315 ist SQL-2<br />
- 34 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
festgelegt. In den Weiterentwicklungen SQL-3 und SQL-4 wurden schließlich<br />
objektorientierte Konzepte integriert.<br />
SQL-1 und SQL-2 sind nicht zu den prozeduralen Sprachen der dritten Generation zu<br />
rechnen, da sie keine allgemeinen Methoden zur Formulierung von Algorithmen<br />
enthalten. So gibt es keine Schleifenkonstrukte und ähnliches. Als Ausgleich dafür<br />
besteht aber die Möglichkeit mit Embedded SQL , SQL-Statements in prozedurale oder<br />
objektorientierte Sprachen einzubetten. Erst durch SQL-3 wurde SQL vollständig und<br />
es kann auch mit SQL jeder Algorithmus ausgedrückt werden.<br />
SQL ist eine Sprache der vierten Generation (4GL). Das heißt in SQL wird nicht<br />
beschrieben, wie ein Datenbankzugriff zu erfolgen hat, es wird vielmehr beschrieben,<br />
was der Anwender beabsichtigt. Vor der Ausführung von SQL-Anweisungen muss<br />
daher eine algorithmische Umsetzung in prozedurale Anweisungen erfolgen, da nur<br />
solche durch einen Computer ausführbar sind. Das hat den großen Vorteil, dass SQL auf<br />
allen Arten von Datenbanken einsetzbar ist.<br />
Seit Jahren arbeitet nun ein Herstellerkonsortium namens SQL Access Group an der<br />
Definition von Einrichtungen zur Verbesserung der Interoperabilität zwischen<br />
unterschiedlichen SQL-Implementierungen. Sie versuchen somit den Standard laufend<br />
zu aktualisieren und zu verbessern. Die aktuelle Sprachversion von SQL heißt SQL-99.<br />
Das entsprechende Standarddokument ist Ende des Jahres 1999 in Kraft getreten – als<br />
offizielles Publikationsdatum wird der 15. November 1999 angegeben – und hat damit<br />
das bisher gültige Standarddokument aus dem Jahre 1992 abgelöst.<br />
Die SQL-Standardisierungskommission vermeidet es, von Relationen, Tupeln und<br />
Attributen zu sprechen. Statt dessen werden Ausdrücke wie Tabelle, Zeile und Spalte<br />
verwendet. Um bei einer sauberen Begriffsverwendung zu bleiben werde ich versuchen<br />
die Begriffe anschließend kurz zu definieren und aufzulisten.<br />
Relationaler Ausdruck SQL-Ausdruck<br />
Relation (Menge) Tabelle<br />
Tupel Zeile<br />
Attribut Spalte<br />
Tabelle 2: Gegenüberstellung von relationalen und SQL-Ausdrücken [Quelle: Pernul/Unland<br />
(2001) S. 263]<br />
SQL wurde als mengenorientierte Sprache konzipiert und hat damit den Vorteil enorm<br />
benutzerfreundlich zu sein. Der Benutzer kann in einer Sprache, die an die Englische<br />
Sprache angelehnt ist, seine Anforderungen an die Datenbank formulieren und erhält<br />
eine entsprechende Ergebnismenge geliefert.<br />
- 35 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
SQL ist sowohl eine DDL (Data Definition Language), eine DML (Data Manipulation<br />
Language) als auch eine DCL (Data Control Language). Diese Unterscheidung ist sehr<br />
wichtig und essentiell und sollte jedem Benutzer von SQL ständig im Bewusstsein<br />
bleiben. Für zusätzliche Publikationen über die Historie von SQL verweise ich auf Goos<br />
(2000), S. 108ff, Härder/Rahm (2001) S. 531, Hartmut (2000), S. 691f und Redaktion<br />
Toolbox (2002) S. 597ff.<br />
3.2.2 DAS RELATIONALE MODELL<br />
Das Relationale Modell, welches als das bedeutendste Datenmodell der Jetztzeit gilt,<br />
geht auf E.F. Codd zurück, der mit Recht als Schöpfer des Relationenmodells<br />
bezeichnet werden kann. In seiner zukunftsweisenden Abhandlung „A relational model<br />
of data banks“ (1970) stellte er erstmals das Relationenmodell vor. Auf Grund der<br />
Bedeutung und realen Anwendung im Zuge meiner Arbeit, will ich detaillierter und<br />
ausführlicher auf die Begriffe und Grundlagen dieses Modells eingehen.<br />
3.2.2.1 RELATIONALE DATENSTRUKTUR<br />
3.2.2.1.1 DOMÄNEN:<br />
Im relationalen Modell werden die Daten als Relationen repräsentiert. Eine Relation ist<br />
auf Domänen definiert.<br />
Eine Domäne<br />
• stellt einen Wertevorrat bereit. Die Werte werden dabei als atomar (skalar,<br />
elementar) vorausgesetzt.<br />
• hat einen Namen.<br />
Diese Eigenschaften gelten im wesentlichen auch für Datentypen, wie sie in höheren<br />
Programmiersprachen unterstützt werden. Tatsächlich kann man sich eine Domäne als<br />
eine Art Datentyp vorstellen. Das Domänenkonzept unterscheidet sich aber<br />
dahingehend, dass der Domänenname von Benutzer selbst definiert wird.<br />
3.2.2.1.2 RELATIONEN:<br />
Eine Relation über den Domänen D1, D2, ...., Dn besteht aus einem Relationenkopf<br />
(heading) und einem Relationenrumpf (body).<br />
Der Relationenkopf besteht aus einer festen, im Zeitablauf nicht änderbaren Menge von<br />
Attributen A1, A2,..., An, so dass jedes Attribut Ai genau einer der zugrundeliegenden<br />
- 36 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Domänen entspricht. Die (feste) Anzahl n der Attribute wird als Grad (degree) der<br />
Relation bezeichnet.<br />
Der Relationenrumpf besteht aus einer variablen, im Zeitablauf veränderlichen Menge<br />
von n-Tupeln, wobei jedes n-Tupel wiederum eine Menge von (Attribut:Wert)-Paaren<br />
(Ai : vi ), i=1,...,n ist. Für jedes Paar (Ai : vi ) ist vi ∈Di. Die Anzahl der n-Tupel wird<br />
Kardinalität der Relation genannt.<br />
• Ein Attribut Ak hat einen innerhalb der Relation eindeutigen Namen,<br />
• der einen Bezug zur zugrundeliegenden Domäne Dk herstellt,<br />
• einen Bezug zum dazugehörigen Wert vk herstellt.<br />
[vgl. Panny/Taudes (2000) S. 23f]<br />
Abbildung 14: Relationale Datenstruktur [in Anlehnung: Panny/Taudes (2000) S. 23]<br />
3.2.2.1.3 EIGENSCHAFTEN VON RELATIONEN<br />
Für Relationen nach der obigen Definition ergeben sich folgende Eigenschaften:<br />
• Es kann niemals mehrfach auftretende identische Tupel in einer Relation<br />
geben.<br />
• Die Tupel einer Relation sind nicht geordnet.<br />
• Auch die Attribute einer Relation sind nicht geordnet.<br />
• Alle Attributswerte sind atomar.<br />
- 37 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
3.2.2.2 RELATIONALE INTEGRITÄT<br />
3.2.2.2.1 SCHLÜSSELKANDIDAT (CANDIDATE KEY)<br />
Sei R eine Relation mit den Attributen A1, A2,..., An.. Die Menge K= {Ai1, Ai2,..., Aim},<br />
m>=1, heißt Schlüsselkandidat von R genau dann, wenn unabhängig vom Zeitpunkt<br />
(also über die gesamte Lebensdauer der Relation R) gilt:<br />
• Eindeutigkeit: Zu keinem Zeitpunkt gibt es zwei Tupel mit demselben Wert für<br />
K.<br />
• Minimalität: Keines der Attribute Ai1, Ai2,..., Aim kann weggelassen werden, ohne<br />
die Eindeutigkeit von K zu verliehren.<br />
3.2.2.2.2 PRIMÄRSCHLÜSSEL (PRIMARY KEY)<br />
Für jede gegebene Relation R muss einer der Schlüsselkandidaten als Primärschlüssel<br />
festgelegt werden. Die übrigen Schlüsselkandidaten heißen Alternativschlüssel<br />
(alternative keys).<br />
3.2.2.2.3 FREMDSCHLÜSSEL (FOREIGN KEY)<br />
Ein Fremdschlüssel ist ein Menge von Attributen einer Relation R2. Es gibt nun in der<br />
Datenbank eine Relation R1, so dass jeder in R2 auftretende Fremdschlüsselwert auch als<br />
Primärschlüsselwert in R1 vorkommt. Die Relationen R1 und R2 sind nicht<br />
notwendigerweise verschieden.<br />
3.2.2.2.4 ENTITÄTSINTEGRITÄT<br />
Für jede definierte Relation muss ein Primärschlüssel festgelegt sein. Kein zum<br />
Primärschlüssel einer Relation gehörendes Attribut, darf Nullwerte annehmen.<br />
3.2.2.2.5 REFERENZIELLE INTEGRITÄT (REFERENTIAL INTEGRITY)<br />
Sei R2 eine Relation, die mit einem Fremdschlüssel F auf die Relation R1 mit dem<br />
Primärschlüssel P zeigt. Für jeden in R2 auftretenden Wert von F muss gelten:<br />
• Er enthält entweder in keiner seiner Komponenten einen Nullwert oder alle<br />
seine Komponenten sind mit Nullwerten markiert.<br />
• Wenn er vollständig definiert ist, muss in R1 ein Tupel existieren, welches<br />
diesen Wert als P-Wert aufweist.<br />
- 38 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Es ist durchaus erlaubt und möglich, dass R1 und R2 identisch sind. In einem solchen<br />
Fall spricht man von einem Selbstbezug.<br />
3.2.2.3 RELATIONALE DATENMANIPULATION<br />
Man unterscheidet grundsätzlich zwei Arten der Datenmanipulation: die Mutation und<br />
die Abfrage. Während bei der Abfrage nichts am Zustand der Daten oder Tupel<br />
verändert wird, ist die Mutation das Hinzufügen, Ändern und Löschen von Daten.<br />
Die Operationen der Relationenalgebra werden nach Panny/Taudes [vgl. Panny/Taudes<br />
(2000) S. 31f] wie folgt eingeteilt:<br />
• Selektion:<br />
Extrahiert bestimmte Tupel aus einer Relation und bildet somit eine horizontale<br />
Teilrelation.<br />
• Projektion:<br />
Extrahiert bestimmte Attribute aus einer Relation und bildet somit eine vertikale<br />
Teilrelation.<br />
• Produkt:<br />
Erzeugt aus zwei Relationen eine neue Relation, die aus allen möglichen Tupeln<br />
besteht, welche man durch Verketten eines Tupels der ersten Relation mit einem<br />
Tupel der zweiten Relation bilden kann.<br />
• Vereinigung:<br />
Erzeugt aus zwei Relationen eine neue Relation, welche die Tupel beider<br />
Relationen enthält.<br />
• Differenz:<br />
Erzeugt aus zwei Relationen eine neue Relation, welche die gemeinsamen Tupel<br />
beider Relationen enthält.<br />
• Verbund:<br />
Erzeugt aus zwei Relationen eine neue Relation, die aus allen möglichen Tupeln<br />
besteht, welche man durch Verketten eines Tupels der ersten Relation mit einem<br />
Tupel der zweiten Relation bilden kann, so dass jedes dieser Paare eine<br />
vorgegebene Bedingung erfüllt.<br />
• Division:<br />
Erzeugt aus zwei Relationen eine neue Relation. Nehmen wir fürs erste<br />
vereinfachend an, die Dividendenrelation habe Grad 2 (sei binär) und die<br />
Divisorrelation habe Grad 1 (sei unär). Dann besteht die Quotientenrelation aus<br />
- 39 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
all jenen Werten des einen Attributs der binären Relation, für die alle Werte der<br />
unären Relation im zweiten Attribut vorkommen.<br />
3.2.2.4 NORMALFORMEN<br />
Normalformen stellen ein Messverfahren für die Qualität und Güte eines<br />
Relationsschemas dar. Sie helfen, Anomalien zu entdecken und damit Redundanzen zu<br />
vermeiden [vgl. Pernul/Unland (2001) S. 140ff]. Die Unterscheidung der Normalformen<br />
basieren auf Codd (1970). In der Folge wird auf die wichtigsten Typen von<br />
Normalformen eingegangen..<br />
3.2.2.4.1 ERSTE NORMALFORM (1NF)<br />
Die Wertebereiche aller Attribute des Relationsschemas müssen atomar sein. Die erste<br />
Normalform verlangt, dass alle Attibutwerte aus einem unstrukturierten Wertebereich<br />
stammen. Mengen, Aufzähltypen, Wiederholungsgruppen oder komplex strukturierte<br />
Wertebereiche sind nicht zugelassen.<br />
3.2.2.4.2 ZWEITE NORMALFORM (2NF)<br />
Die zweite Normalform bedeutet, dass es keine Teilmenge eines Schlüsselkandidaten<br />
geben darf, die ein nicht primes Attribut funktional bestimmt. Um die zweite<br />
Normalform überprüfen zu können, muss man zuvor alle Schlüsselkandidaten ermitteln,<br />
denn nur Attribute, die in keinem Schlüsselkandidaten enthalten sind, können die zweite<br />
Normalform verletzen.<br />
3.2.2.4.3 DRITTE NORMALFORM (3NF)<br />
Die dritte Normalform setzt die zweite Normalform voraus und fordert zusätzlich, dass<br />
zwischen einem nicht-primen Attribut und einem Schlüsselkandidaten keine transitive<br />
funktionale Abhängigkeit existieren darf.<br />
Funktionale Abhängigkeiten sind im Relationenmodell die wichtigste Klasse von<br />
Einschränkungen. Sie werden verwendet, um die Anzahl der mathematisch möglichen<br />
Tupel (kartesisches Produkt der Attributswertebereiche) auf die Menge der semantisch<br />
sinnvollen Tupel einzuschränken. Die funktionale Abhängigkeit X → Y (X bestimmt Y<br />
funktional) gilt im Schema R, falls alle beliebigen Tupel t 1 , t2<br />
aus der Relation r(R), die<br />
in ihren X-Werten übereinstimmen, auch in ihren Y-Attributen identische Werte<br />
aufweisen.<br />
- 40 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
3.2.2.4.4 BOYCE-CODD-NORMALFORM (BCNF)<br />
Die Boyce-Codd-Normalform setzt die dritte Normalform voraus. Sie ist die einzige<br />
Normalform, die durch gültige funktionale Abhängigkeiten und nicht durch nicht-prime<br />
Attribute verletzt werden kann. In Relationsschemata in der Boyce-Codd-Normalform<br />
gibt es keine nennenswerten Anomalien mehr.<br />
3.2.2.4.5 VOR- UND NACHTEILE DER NORMALISIERUNG<br />
Nachteile der Normalisierung:<br />
• Unübersichtlichere und schwieriger zu handhabende Datenbanken, da durch die<br />
Normalisierung mehr Tabellen entstehen.<br />
• Höhere Antwortzeiten durch die Notwendigkeit, Views einzuführen sowie Joins<br />
bei Datenbankabfragen zu verwenden.<br />
Vorteile der Normalisierung:<br />
• Verminderung von Redundanz durch Auslagerung von redundanter Information<br />
in separate Tabellen.<br />
• Weniger Anomalien.<br />
• Mehr Konsistenz.<br />
• Speicherplatzersparnis.<br />
[vgl. Kleinschmidt/Rank (2002) S. 78]<br />
3.2.2.5 SICHTEN (VIEWS)<br />
Ein View kann auch als virtuelle Relation bezeichnet werden, welche nicht selbständig<br />
besteht, sondern dynamisch von einer oder mehreren Grundrelationen abgeleitet wird.<br />
Eine Sicht kann durch Operationen wie die Auswahl, Projektion und Verknüpfung der<br />
relationalen Algebra oder anderen Berechnungen aus den Werten der Grundrelationen<br />
erzeugt werden.<br />
3.2.2.5.1 TERMINOLOGIE<br />
„Eine Sicht ist das dynamische Ergebnis einer oder mehrerer relationaler Operationen,<br />
die an einer Grundrelation ausgeführt wurden, um eine andere Relation zu erzeugen.<br />
Eine Sicht ist eine virtuelle Relation, die nicht tatsächlich in der Datenbank vorhanden<br />
ist, sondern auf die Anfrage des einzelnen Benutzers zu Zeit der Anfrage erzeugt wird.“<br />
[vgl. Connolly et al. (2002) S. 138]<br />
- 41 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
3.2.2.5.2 ZWECK VON SICHTEN<br />
Der Zweck, bzw. die Vorteile von Sichten sind:<br />
• Teile der Datenbank bleiben vor bestimmten Benutzern verborgen. Dies liefert<br />
einen leistungsfähigen und flexiblen Sicherheitsmechanismus.<br />
• Es erlaubt den Benutzern, auf eine ihren Bedürfnissen angepasste Weise auf die<br />
Daten zuzugreifen, so dass dieselben Daten für verschiedene Benutzer zur<br />
selben Zeit auf unterschiedliche Weise sichtbar sind.<br />
• Er kann komplexe Operationen an Grundrelationen vereinfachen. Wenn eine<br />
Sicht zum Beispiel als Verknüpfung zweier Relationen definiert ist, kann der<br />
Benutzer nun die einfacheren Operationen der Auswahl und Projektion an der<br />
Sicht durchführen. Das Datenbanksystem übersetzt sie in die entsprechenden<br />
Operationen an der Verknüpfung.<br />
[vgl. Connolly et al. (2002) S. 138f]<br />
3.2.2.5.3 AKTUALISIERUNG VON SICHTEN<br />
Alle Aktualisierungen einer Grundrelation sollten sich unmittelbar in allen Sichten<br />
widerspiegeln, die sich auf diese Grundrelation beziehen. Ebenso sollte die zugrunde<br />
liegende Grundrelation die Änderung anzeigen, wenn eine Sicht aktualisiert wird. Es<br />
gibt jedoch Einschränkungen in Bezug auf die Art der Änderungen, die mit Hilfe von<br />
Sichten durchgeführt werden können.<br />
Aktualisierungen mit Hilfe einer Sicht sind zulässig, wenn eine einfache Abfrage<br />
bezogen auf eine einzelne Grundrelation benutzt wird, die entweder den Primärschlüssel<br />
oder einen Schlüsselkandidaten der Grundrelation enthält.<br />
Aktualisierungen mit Hilfe von Sichten sind nicht zulässig, wenn mehrere<br />
Grundrelationen betroffen sind.<br />
Aktualisierungen mit Hilfe von Sichten sind nicht zulässig bei Aggregations- oder<br />
Gruppierungs-Operationen.<br />
3.2.3 SQL NACH DEM STANDARD SQL 99<br />
SQL als Datenbanksprache stellt die sprachliche Schnittstelle zum Anwender dar.<br />
Damit stellt sie Beschreibungsmittel für die strukturellen und manipulativen Aspekte<br />
der Daten bereit. Entsprechend werden üblicherweise die Teilsprachen<br />
Datendefinitionssprache (DDL), Datenmanipulationssprache (DML) und<br />
Datenkontrollsprache (DCL) der Datenbanksprache SQL unterschieden und unten<br />
- 42 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
erläutert. Als weiterführende Literatur sei dabei Achilles (2000) S.119ff, Houlette<br />
(2001) S. 59ff, Marsch/Fritze (1999) S. 57ff und Panny/Taudes (2000) S. 71ff genannt.<br />
3.2.3.1 SQL ALS DDL<br />
Ursprünglich gingen die ersten Versionen von SQL von der Vorstellung aus, dass die<br />
Struktur einer Datenbank zeitlich festgeschrieben und durch die Struktur der Tabellen<br />
und Zugriffsrechte festgelegt ist. Deshalb war ursprünglich nur vorgesehen<br />
Datenbankobjekte anzulegen, nicht aber sie zu ändern oder zu löschen. Dies wurde erst<br />
in späterer Folge in den Standard integriert.<br />
Zum Erzeugen, Ändern und Löschen von DBMS-Objekten<br />
(Datenbankmanagementsystem-Objekten) sieht der Standard drei Kategorien von<br />
Anweisungen vor, die CREATE-, die ALTER- und die DROP-Anweisungen. Um<br />
Zugriffsrechte an den erzeugten DBMS-Objekten zu vergeben bzw. zu entziehen, stehen<br />
die GRANT- bzw. REVOKE-Anweisung zur Verfügung<br />
Im Anschluss möchte ich Anhand der TABLE Anweisungen für jede einzelne Kategorie<br />
exemplarisch die Struktur der SQL-Anweisungen demonstrieren, da eine intensivere<br />
Betrachtung jedes einzelnen DBMS-Objektes (also auch Indizes, Views, …) separat den<br />
Rahmen dieser Arbeit sprengen würde und diese analog betrachtet werden können.<br />
3.2.3.1.1 ERZEUGEN VON DBMS-OBJEKTEN (CREATE)<br />
Syntax:<br />
CREATE TABLE table_name<br />
( {spalten_name {domain_name | datentyp}<br />
[spalten_constraint]<br />
[DEFAULT voreinstellung]<br />
[COLLATE anordnung]<br />
| table_contraint<br />
}, … );<br />
3.2.3.1.2 ÄNDERN VON DBMS-OBJEKTEN (ALTER)<br />
Syntax:<br />
ALTER TABLE tabellen_name<br />
{ ADD [COLUMN] spaltendefinition }<br />
| { ALTER [COLUMN] spalten_name<br />
{{ SET DEFAULT default } | { DROP DEFAULT }}<br />
}<br />
| { DROP [COLUMN] spalten_name {RESTRICT |<br />
CASCADE}}<br />
| { ADD table_constraint }<br />
- 43 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
| { DROP CONSTRAINT constraint_name {RESTRICT |<br />
CASCADE}}<br />
Löschen von DBMS-Objekten (DROP)<br />
Syntax:<br />
DROP TABLE table_name { CASCADE | RESTRICT }<br />
3.2.3.1.3 VERGABE VON RECHTEN (GRANT)<br />
Syntax:<br />
GRANT { ALL PRIVILEGES<br />
| SELECT<br />
| DELETE<br />
| { INSERT [(spalte [, ...])}<br />
| { UPDATE [(spalte [, ...])}<br />
| { REFERENCES [(spalte [, ...])}<br />
} [, ...]<br />
ON [ TABLE ] table_name<br />
TO { benutzer1 [, benutzer2, …] } | PUBLIC<br />
[ WITH GRANT OPTION]<br />
3.2.3.1.4 ENTZIEHEN VON RECHTEN (REVOKE)<br />
Syntax:<br />
REVOKE [ GRANT OPTION FOR]<br />
Recht [, …] ON objekt<br />
FROM { benutzer1 [, benutzer2, …] } | PUBLIC<br />
{ CASCADE | RESTRICT}<br />
3.2.3.2 SQL ALS DML<br />
SQL als Datenmanipulationssprache unterstützt sowohl Abfragen (SELECT), als auch<br />
Mutationen (INSERT, UPDATE, DELETE), welche die zugrunde liegenden Tabellen<br />
verändern.<br />
3.2.3.2.1 DIE SELECT ABFRAGE<br />
Die Abfrage ist das mächtigste und vielseitigste Instrument das SQL zu bieten hat. Man<br />
hat mit einer SQL Abfrage unglaubliche Möglichkeiten, die jedoch in den wenigsten<br />
Fällen benutzt werden. Zumeist beschränken sich die Anwender auf einfachste<br />
Abfragen.<br />
Syntax:<br />
SELECT [ ALL | DISTINCT ] selektionsliste<br />
FROM tabellenreferenzen<br />
- 44 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
[ WHERE suchbedingung ]<br />
[ GROUP BY spaltenliste ]<br />
[ HAVING gruppensuchbedingung ]<br />
3.2.3.2.2 DIE INSERT ANWEISUNG<br />
Syntax:<br />
INSERT INTO tabelle<br />
[ spalte i [, spalte j, ...])]<br />
{ select_anweisung<br />
| tab_konstruktor<br />
| { DEFAULT VALUES<br />
}<br />
3.2.3.2.3 DIE UPDATE ANWEISUNG<br />
Syntax:<br />
UPDATE tabelle<br />
SET spalte i = { ausdruck i | NULL | DEFAULT }<br />
[, spalte j = { ausdruck j | NULL | DEFAULT }<br />
...]<br />
[ WHERE suchbedingung ]<br />
3.2.3.2.4 DIE DELETE ANWEISUNG<br />
Syntax:<br />
DELETE FROM tabelle<br />
[ WHERE suchbedingung]<br />
3.2.3.3 SQL ALS DCL<br />
SQL ist auch eine Datenkontrollsprache (DCL), die dazu dient die<br />
Transaktionseinheiten festzulegen und Sperren auf die benutzten Datenbankobjekte<br />
anzufordern.<br />
Im vollen Sprachumfang von SQL-99 sind eigene Verbindungsanweisungen<br />
(connection statements) vorgesehen mit Hilfe derer der Benutzer den Auf- bzw. Abbau<br />
und die Verwaltung von SQL-Verbindungen explizit steuern kann. Insbesondere sind<br />
nun im Prinzip auch mehrere gleichzeitig bestehende Verbindungen zu mehreren SQL-<br />
Servern und sogar serverübergreifende Transaktionen möglich. In Core SQL, das den<br />
Sprachkern von SQL-99 darstellt, kann aber für einen SQL-Agenten immer nur eine<br />
einzige Verbindung bestehen.<br />
- 45 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Zu jeder SQL-Verbindung gehört auch eine SQL-Sitzung (SQL Session). Sie wird mit<br />
dem Aufbau der Verbindung gestartet und mit dem Abbruch der SQL-Verbindung<br />
beendet. Dabei sind folgende zum Kontext einer Sitzung gehörende Bestandteile von<br />
Relevanz:<br />
• Die Benutzerkennung der SQL-Sitzung<br />
• Der Default-Katalogname<br />
• Der Default-Schemaname<br />
• Der SQL-Pfad<br />
Diese zum Kontext der Sitzung gehörenden Charakteristika können nicht verändert<br />
werden und haben einen Readonly Status. Die entsprechenden, zu Beginn der Sitzung<br />
gesetzten Werte bleiben notwendigerweise bis zum Ende der Sitzung in Kraft.<br />
Den Kern der Datenkontrolle bildet jedoch die Kontrolle über die Transaktionen. Eine<br />
Transaktion umfasst eine Folge von nacheinander auszuführenden SQL-Anweisungen.<br />
In Core SQL wird eine Transaktion durch die erste Anweisung gestartet, die den<br />
Rahmen der Transaktion voraussetzt. Es gibt zwei Anweisungen um eine Transaktion<br />
abzuschließen: COMMIT und ROLLBACK. Wird eine Transaktion durch COMMIT<br />
beendet, werden alle Mutationen dauerhaft gespeichert. Wird eine Transaktion durch<br />
ROLLBACK abgeschlossen, wird die Datenbank in den konsistenten Zustand vor der<br />
Transaktion zurückgesetzt. Keine der im Rahmen der Transaktion durchgeführten<br />
Anweisungen hat einen Effekt.<br />
4 ERP-SYSTEME<br />
ERP-Systeme (Enterprise Resource Planning) sind betriebliche Planungs- und<br />
Steuerungssysteme. Wichtige Bestandteile dieser industriellen, meist sehr<br />
umfangreichen, Softwaresysteme sind die Produktionsplanung und –steuerung, die<br />
bedarfs- und verbrauchsgesteuerte Materialdisposition, die Fakturierung, die<br />
Kundenbetreuung, die Buchhaltung und Projektplanung. Als führende Hersteller sind<br />
SAP, PeopleSoft, Baan, Oracle und Edwards zu nennen. [vgl. Schneider/Werner S. 726]<br />
Für unser Projekt sind die ERP-Systeme als Quelle für unsere Daten für das Data<br />
Warehouse anzusehen. Diese ERP-Systeme bestehen aber wiederum aus<br />
unterschiedlichen Datenbanken, wodurch eine einheitliche Datenschnittstelle über die<br />
Einführung von Übertragungsregeln der Datentransformationsprozesse festgelegt<br />
werden müssen [vgl. Seemann et al. (2001) S. 27].<br />
- 46 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
5 DAS DATA WAREHOUSE<br />
5.1 DAS KONZEPT DES DATA WAREHOUSE<br />
Unternehmen sind heutzutage prozess- oder transaktionsorientiert. Durch viele<br />
Standardsoftwareanbieter werden Geschäftsprozesse durch das Erfassen von<br />
Transaktionen abgebildet und erfasst. In Management- und Informationssystemen, die<br />
der Entscheidungsunterstützung und Entscheidungsfindung dienen, benötigt man jedoch<br />
detaillierte Daten, die es erlauben, die Informationen vieler Geschäftsprozesse als<br />
Ganzes zu analysieren. Diese, zumeist aggregierten, Daten erlauben erst aus der Fülle<br />
der Transaktionsdaten Informationen zu gewinnen. Diese Informationen sind höchst<br />
wertvoll für die Entscheidungsträger eines Unternehmens, da erst diese Informationen<br />
eine fundierte strategische oder taktische Entscheidung ermöglichen. Data Warehousing<br />
hat darüber hinaus die Aufgabe, aus Daten nicht nur Informationen abzuleiten, sondern<br />
diese Informationen in Wissen weiterzuentwickeln und dann in Aktionen zu wandeln.<br />
Mit einem Data Warehouse werden also Unternehmensprozesse (Geschäftsprozesse)<br />
kontrolliert und gesteuert. Somit stellt der Data Warehouse Ansatz den Übergang vom<br />
reinen Datenmanagement hin zur höheren Entwicklungsstufe des<br />
Informationsmanagements dar. [vgl. Martin (1998) S. 11 ff]<br />
„Ein Data Warehouse ist ein umfassendes Konzept zur Entscheidungsunterstützung von<br />
Mitarbeitern aller Bereiche und Ebenen“ [vgl. Stock (2000) S. 51].<br />
Somit hat ein Data Warehouse folgende Merkmale:<br />
• Orientierung an den unternehmensbestimmenden Sachverhalten<br />
(subjektorientiert):<br />
Typische Subjekte der Betrachtung sind z.B. Kunden, Produkte, Lieferanten.<br />
Man fokussiert inhaltliche Kernbereiche der Organisation.<br />
• Zeitraumbezug (zeitabhängig):<br />
Es werden Daten benötigt, welche die Entwicklung eines Unternehmens über<br />
einen bestimmten Zeitraum repräsentieren und damit zum Erkennen von Trends<br />
herangezogen werden können. Dies geschieht meist durch Einbindung des<br />
betrachteten Zeitraumes in die entsprechenden Schlüssel der Daten.<br />
• Struktur- und Formatvereinheitlichung (integriert und vereinheitlicht):<br />
Dieses Merkmal wird erfüllt durch einheitliche Konventionen (bezüglich<br />
Namensgebung, Dateiattributen, etc.), einheitliche Datenformate (z.B.<br />
Werteinheiten) und semantischer Integrität (z.B. Angleichen unterschiedlicher<br />
Kontenrahmen, Währungsumrechnungen, etc.). Ziel ist eine konsistente<br />
Datenmenge im Data Warehouse.<br />
- 47 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
• Nicht-Volatilität – nur lesender Zugriff (beständig bzw. dauerhaft):<br />
Dauerhafte Speicherung über größere Zeiträume. Die wichtigsten Operationen<br />
sind das <strong>Download</strong>en und die Datenabfrage.<br />
„Derartige Data Warehouse Systeme sind heute nicht als fertiges Produkt verfügbar,<br />
sondern unternehmensindividuell zu konzipieren und zu realisieren, weshalb es<br />
angebracht erscheint, eher von einem Data Warehouse Konzept als von einem Data<br />
Warehouse System zu sprechen“ [vgl. Gabriel/Röhrs (2003) S. 340]. Für eine analoge<br />
Definition der Merkmale des Datawarehouse und auch für zusätzliche Ausführung<br />
verweise ich auf Kemper (1999) S. 458ff, Mertens (2000) S. 20, Schneider/Werner<br />
(2000) S. 526 oder Shaw (2000), S. 502ff.<br />
5.2 ARCHITEKTUR EINES DATAWAREHOUSE<br />
In diesem Abschnitt will ich einen Überblick über die Architektur und die wesentlichen<br />
Komponenten in einem Data Warehouse geben. Dazu wurde eine typische Architektur<br />
im Data Warehouse in Abbildung 15 graphisch dargestellt.<br />
- 48 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
5.2.1 OPERATIVE DATEN<br />
Abbildung 15: Die Architektur eine Data Warehouse<br />
[Quelle: in Anlehnung an Posser/Ossimitz (2001) S. 26]<br />
Das Datawarehouse wird durch eine Reihe von unterschiedlichen operativen<br />
Datenquellen gespeist. Diese individuellen Datenbanken können auf unterschiedlichen<br />
Systemen in unterschiedlichen Formaten vorliegen.<br />
- 49 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
5.2.2 EXTERNE DATENBANKEN<br />
Dies können Datenbanken von externen Anbieter oder frei zugängliche Datenquellen<br />
sein, welche in das Datawarehouse integriert werden.<br />
5.2.3 DIE METADATEN<br />
Meta-Daten enthalten die Aufzeichnungen darüber, wie die operativen Daten aufgebaut<br />
sind, wie die Daten im Data Warehouse aufgebaut sind und wie externe Quellen in das<br />
Data Warehouse integriert werden. Meta-Daten sind Datenbanken, die ein Bestandteil<br />
des Data Warehouse sind. Sie sind vor allem für die Datenbankadministratoren des<br />
Data Warehouse von Bedeutung.<br />
5.2.4 DIE DATENPUMPEN<br />
Datenpumpen (Transaktionsprogramme, Lademanager, Frontend-Komponente) führt<br />
alle mit dem Extrahieren und Laden der Daten in das Data Warehouse verbundenen<br />
Tätigkeiten aus. Dazu gehören einfache Umwandlungen der Daten, um diese für die<br />
Eingabe in das Warehouse vorzubereiten.<br />
5.2.5 DER DATAWAREHOUSE MANAGER<br />
Der Data Warehouse Manager führt alle mit der Verwaltung der Daten im Warehouse<br />
verbundenen Tätigkeiten aus. Dabei ist diese Software insbesondere für folgende<br />
Tätigkeiten zuständig:<br />
• Analyse der Daten, um die Konsistenz zu gewährleisten<br />
• Umformen und Zusammenführen von Quelldaten aus der temporären<br />
Speicherung in Data Warehouse Tabellen<br />
• Erstellen von Indizes und Ansichten der Basistabellen<br />
• Denormalisierung (falls erforderlich)<br />
• Aggregatbildung (falls erforderlich)<br />
• Anlegen von Sicherheitskopien und Archivieren der Daten<br />
[vgl. Connolly et al. (2002) S. 915]<br />
5.2.6 ZUGRIFFSWERKZEUGE FÜR DEN ENDBENUTZER<br />
Der vorrangige Zweck eines Data Warehouse besteht darin, den Benutzern Information<br />
zu liefern, damit sie fundierte Entscheidungen fällen können. Diese Endbenutzer<br />
- 50 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
müssen über Zugriffswerkzeuge mit dem Data Warehouse interagieren können, um die<br />
ad hoc und Routineanalysen effizient zu unterstützen. Anschließend sind diese in fünf<br />
Gruppen eingeteilt, wobei zu bemerken ist, dass es in der Praxis sehr oft zu<br />
Überschneidungen zwischen den Gruppen kommt. [vgl. Connolly et al. S. 916ff]<br />
5.2.6.1 WERKZEUGE FÜR BERICHTE UND ABFRAGEN<br />
Die wichtigsten Werkzeuge für den Benutzer sind diejenigen, die ihm die Informationen<br />
liefern. Es erfolgt die Eingabe einer Benutzeranforderung und eine entsprechende<br />
graphische oder textorientierte Präsentation der Ergebnisse. Üblicherweise werden von<br />
den Anwendungen im Hintergrund SQL-Statements generiert, welche die Informationen<br />
aus dem Data Warehouse abfragen. Zusätzlich ist jedoch zu bemerken, dass diese<br />
Werkzeuge ihre Datenbasis nicht nur aus dem Data Warehouse erhalten, sondern zum<br />
Teil auch Daten aus den operativen Systemen direkt in die Präsentation einbeziehen.<br />
5.2.6.2 WERKZEUGE ZUR ENTWICKLUNG VON ANWENDUNGEN<br />
Da leider sehr oft Standardanwendungsprogramme für individuelle<br />
Benutzeranforderungen ungeeignet sind, gibt es Werkzeuge die Benutzern mit<br />
ausreichender Fachkenntnis erlauben hauseigene Abfrage- und Präsentationstools zu<br />
entwickeln.<br />
5.2.6.3 EXECUTIVE INFORMATION SYSTEM WERKZEUGE (EIS)<br />
Executive Information Systems sind ursprünglich zur Unterstützung strategischer<br />
Entscheidungsfindung auf höchster Ebene entwickelt worden. Sie haben jedoch ihren<br />
Schwerpunkt erweitert und unterstützen jetzt alle Verwaltungsebenen. EIS-Werkzeuge<br />
standen ursprünglich mit Großrechnern in Zusammenhang, die Benutzer in die Lage<br />
versetzten, individualisierte graphische Entscheidungsunterstützungswerkzeuge zu<br />
erstellen, die einen Überblick über die Organisationsdaten und Zugriff auf externe<br />
Datenquellen bereitstellen sollten.<br />
Auf dem heutigen Markt ist die Abgrenzung zwischen EIS-Werkzeugen und anderen<br />
entscheidungsunterstützenden Werkzeugen noch weniger klar, weil EIS-Entwickler<br />
zusätzliche Abfragefähigkeiten einbauen und Anwendungen für Geschäftsbereiche wie<br />
Vertrieb, Marketing und Finanzen liefern. Beispiele für EIS-Werkzeuge sind Lightship<br />
von Pilot Software Inc., Forest and Trees von Platinum Technologies und Express<br />
Analyser von Oracle.<br />
- 51 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
5.2.6.4 DECISION SUPPORT SYSTEME (DSS)<br />
Ein DSS ist ein System, welches für die taktische und strategische<br />
Entscheidungsunterstützung zur Verfügung gestellt wird. Techniken wie Sensibilitätsoder<br />
What If Analysen stehen im Vordergrund solcher Anwendungen. Je nach<br />
speziellem Anwendungsgebiet (Liquitätsmanagement, Portfoliomanagement,<br />
Bonitätsprüfung, etc.) werden wieder unterschiedliche Anwendungssysteme entwickelt.<br />
[vgl. Dippold et al. S. 189]<br />
5.2.6.5 ONLINE ANALYTICAL PROCESSING WERKZEUGE (OLAP)<br />
Online Analytical Processing Werkzeuge basieren auf den Konzepten<br />
mehrdimensionaler Datenbanken und erlauben dem erfahrenen Benutzer, die Daten mit<br />
Hilfe komplexer mehrdimensionaler Ansichten zu analysieren. Der Begriff OLAP<br />
wurde von Codd im Jahre 1993 geprägt; er bezeichnete eine Architektur, die komplexe<br />
analytische Anwendungen unterstützt. OLAP Architekturen werden heute mit Hilfe<br />
spezialisierter mehrdimensionaler Datenbanktechnologie, einer eng begrenzten<br />
Datenmenge und einer individuell angepassten Benutzerschnittstelle implementiert.<br />
5.2.6.6 DATA MINING WERKZEUGE<br />
Als Data Mining wird der Prozess bezeichnet, bei dem große Data Warehouses oder<br />
Data Marts durchforstet werden. Dabei wird mit statistischen und mathematischen<br />
Methoden, sowie Methoden der künstlichen Intelligenz operiert und versucht neue<br />
Korrelationen, Muster oder Trends zu entdecken. Data Mining besitzt das Potential, die<br />
Fähigkeiten der OLAP-Werkzeuge abzulösen, da seine Hauptanziehungskraft in der<br />
Fähigkeit liegt, anstelle retrospektiver Modelle vorhersehende Modelle zu erstellen.<br />
Dadurch versucht man durch Data Mining Werkzeuge den Gap zwischen dem reinen<br />
Generieren der Daten und dem Verstehen der selben zu schließen. Dieser Prozess kann<br />
automatisch oder semiautomatisch passieren und sollte einen ökonomischen Vorteil<br />
bringen. [vgl. Witten/Eibe (2000) S. 1ff]<br />
Data Mining Techniken können grundsätzlich in fünf verschiedene Klassen unterteilt<br />
werden:<br />
• Predictive Modeling:<br />
Man versucht festzustellen, ob einige Felder in der Datenbank auf anderen<br />
Feldern basieren. Dies wird durch Regressionsanalyse bei numerischen Werten<br />
und durch Klassifizierung bei kategorischen Werten versucht.<br />
• Clustering:<br />
Diese Methode wird auch gelegentlich als “Segmentation“ bezeichnet. Dazu<br />
- 52 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
wird eine Anzahl vom Clustern definiert und die Daten entsprechend<br />
eingeordnet.<br />
• Data summarization:<br />
Dabei wird versucht die Daten zu summieren, in Gruppen aufzuteilen und zu<br />
analysieren. Ein sehr treffendes Beispiel wäre die Konsumentenwarenkorb-<br />
Analyse, wo man zu erkennen versucht, welche Produkte gemeinsam mit<br />
welchen gekauft werden.<br />
• Dependency modelling:<br />
Man versucht funktionelle Zusammenhänge zwischen den Datenfelder<br />
festzustellen.<br />
• Change and deviation detection:<br />
Diese Methoden werden für sequenzielle Informationen, wie Zeitreihen oder<br />
genetische Pläne, verwendet.<br />
[vgl. Džeroski/Lavrač (2001) S. 34ff]<br />
5.3 OPERATIVE UND ANALYTISCHE DATEN<br />
In Datenbanksystemen unterscheidet man operative und analytische Datenbanken.<br />
Diese Unterscheidung ist besonders in dem Konnex Data Warehouse eine essentielle.<br />
Operative Datenbanksysteme sind Systeme, die den laufenden Geschäftsbetrieb<br />
(Transaktionsdaten) erfassen und verwalten. Diese werden auch als Online Transaction<br />
Processing (OLTP) Datenbanksysteme bezeichnet. Operative Daten sind<br />
unübersichtlich, weil sie eine Vielfalt von Details unterschiedlicher Anwendungen<br />
enthalten. In analytischen Datenbanksystemen werden umfangreiche Auszüge aus<br />
operativen Daten periodenweise erzeugt und entweder zusammengefasst (aggregiert)<br />
oder detailliert zur flexiblen Analyse bereitgestellt. Deshalb enthalten analytische<br />
Systeme im Gegensatz zu operativen Systemen auch historische Daten. [vgl. Lusti,<br />
Markus (1999), S. 123 ff]<br />
Eigenschaften Operative Daten Data Warehouse<br />
Prozess transaktionsintensiv abfrageintensiv<br />
Benutzer große Anzahl relativ geringe Anzahl<br />
Umfang meist nur aktuelle Daten<br />
- 53 -<br />
aktuelle und historische<br />
Daten<br />
Aktualisierung ständig aktualisiert sporadisch aktualisiert
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Integration funktionell<br />
- 54 -<br />
subjektorientiert und<br />
verdichtet<br />
Datenqualität normal systemabhängig<br />
Datenbanksystem<br />
Datenmodel<br />
Anwendungsbereich<br />
Entwicklung<br />
Zuordnung<br />
Daten werden regelmäßig<br />
aktualisiert<br />
Daten sind normalisiert,<br />
Modellierung aufgrund der<br />
Transaktionen<br />
definiert durch den Bereich<br />
der operativen<br />
Transaktionsanwendung<br />
(statisch, detailliert)<br />
meist werden OLTP-Systeme<br />
eingesetzt<br />
eindeutige Prozesshierarchie<br />
der Benutzer zuordenbar<br />
intervallweise Aktualisierung<br />
der Daten<br />
Daten sind nicht normalisiert,<br />
Modellierung aufgrund der<br />
Dimensionen des Subjektes<br />
liefert ein flexibles,<br />
erweiterbares Entscheidungs-<br />
Unterstützungsinstrument<br />
(flexibel, aggregiert)<br />
Data Warehouse wird<br />
wiederholt erzeugt und<br />
entwickelt<br />
komplexe Benutzerhierarchie<br />
unterschiedlicher<br />
Entscheidungsebenen<br />
Verfügbarkeit Hohe Verfügbarkeit geringe Verfügbarkeit<br />
Identifikationskriterium eindimensional mehrdimensional<br />
Datenmanipulation<br />
zeilenbezogen /<br />
aktualisierend<br />
sichtspezifisch / analysierend<br />
Tabelle 3: Vergleich operative Daten und Data Warehouse [in Anlehnung: Connolly et al. (2002) S.<br />
910; Prosser, Ossimitz (2000 a), S. 11]
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
5.4 AUFBAUEN UND AKTUALISIEREN EINES DATAWAREHOUSE<br />
AUS DEN DATENQUELLEN<br />
5.4.1 KLASSISCHE VORGEHENSWEISE BEIM AUFBAUEN UND<br />
AKTUALISIEREN EINES DATAWAREHOUSE<br />
Der Aufbau eines Data Warehouse beginnt mit einer Auswahl der geeigneten Attribute<br />
aus den operativen Datenbanksystemen. Zusätzlich werden diese meist durch<br />
Informationen aus unternehmensexternen Quellen, z. B. Anbieter von<br />
Marktforschungsergebnissen, ergänzt. Sowohl externe, als auch interne Daten werden<br />
vor ihrer Integration in ein Data Warehouse transformiert. Dabei werden zuerst die<br />
Daten ohne Veränderungen direkt aus den operationalen und externen Datenquellen<br />
kopiert. In einem weiteren Schritt wird Irrelevantes weggelassen, Neues hinzugefügt<br />
und Bestehendes umgeordnet oder verdichtet. Die Daten liegen dann in einer so<br />
genannten Basisfaktentabelle (BFT) vor. Dieser Vorgang wird durch sogenannte<br />
Datenpumpen (siehe 5.2.4) durchgeführt. Das Durchsuchen einer Basisfaktentabelle mit<br />
vielen Einträgen kostet allerdings Zeit und kann auch nicht beliebig beschleunigt<br />
werden. Daher werden in einem Data Warehouse meist vorgefertigte Aggregate<br />
hinterlegt. Diese werden in wenig und stark zusammengefasste Daten unterteilt [vgl.<br />
Connolly et al. (2002) S. 915f]. Diese aggregierten, zusammengefassten Daten können mit<br />
dem Synonym des materialisierten View bezeichnet werden.<br />
Transformationen, die Aufnahme historischer und externer Daten, sowie die<br />
gleichzeitige Haltung von Detaildaten und Aggregaten führen dazu, dass analytische<br />
Datenbanken in der Regel größer werden als ihre operativen Quellen. Wie und in<br />
welcher Art und Weise die operativen Daten verändert, aggregiert oder umgeordnet<br />
werden, ist abhängig vom konzeptionellen Modell des Data Warehouse, welches sich<br />
wiederum aus den Benutzeranforderungen ergibt.<br />
5.4.2 NEUE ANSÄTZE FÜR DAS AUFBAUEN UND AKTUALISIEREN DER<br />
MATERIALISIERTEN SICHTEN<br />
Eine Datawarehouse enthält große Mengen an Information, welche aus<br />
unterschiedlichen Datenquellen stammt. Üblicherweise werden die Daten im<br />
Warehouse mit den Daten in den Datenquellen in regelmäßigen Intervallen aktualisiert<br />
und die neuen Aggregate erzeugt und gespeichert. Allerdings ist das Zeitfenster für das<br />
Aktualisieren beschränkt. Deshalb gibt es unterschiedlichste Ansätze dieses Problem zu<br />
lösen oder zu umgehen.<br />
- 55 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
5.4.2.1 DER WHIPS PROTOTYP<br />
Der Ansatz der WHIPS (Warehousing Information Project at Stanford), welcher an der<br />
Stanford University entwickelt wurde, geht von der in Abbildung 16 angeführten<br />
Struktur aus. Dabei werden als die Hauptkomponenten des Warehouse die „Data<br />
Querying & Analysis“ Komponente, verantwortlich für die Erfüllung der<br />
Informationsbedürfnisse der Benutzer und die „Data Integration“ Komponente, welche<br />
für die Datensammlung und die Erzeugung der materialisierten Sichten verantwortlich<br />
ist, angeführt. Diese zwei Komponenten können nicht unabhängig voneinander gesehen<br />
werden. So basiert die Auswahl der materialisierten Sichten, welche durch den Data<br />
Integrator materialisiert werden, auf den erwarteten Bedürfnissen der Benutzer.<br />
Abbildung 16: Die Basisarchitektur des WHIPS Systems [Quelle: Labio et al. (1997) S. 557]<br />
In Abbildung 17 wird die Data Integration Komponenten näher beleuchtet. Dabei wurde<br />
in Stanford jedes Modul als CORBA Objekt implementiert. Das relationale Modell<br />
wurde für das Warehouse verwendet.<br />
- 56 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 17: Die WHIPS System Architektur für Warehouse Maintenance [Quelle: Labio et at<br />
(1997) S. 558]<br />
Jede Quelle hat einen Wrapper und einen Monitor. Der Monitor hat die Aufgabe die<br />
Datenquelle zu überwachen und bei Änderungen in der Basisdatenquelle den Integrator<br />
darüber in Kenntnis zu setzen. In Stanford wurden triggerbasierende Monitore für die<br />
relationalen Datenquellen und Snapshot Monitore für andere Datenquellen, wo nur<br />
periodische Aktualisierungen möglich sind, eingesetzt. Der Wrapper hat die Aufgabe<br />
die Abfragen der unterschiedlichen Datenquellen zu übersetzen. Stellt also der Query<br />
Processor eine Anfrage an einen Wrapper, übersetzt er diese Query entsprechend der<br />
zugrunde liegenden Datenquelle. Die zentrale Rolle hat der Integrator inne. Er erhält die<br />
Änderungsmeldungen der Monitore, weiß welche Querys von den gemeldeten<br />
Datenquellen betroffen sind und benachrichtigt die entsprechenden View Manager die<br />
betroffenen materialisierten Sichten, bzw. Tupel im Data Warehouse zu aktualisieren.<br />
Die View Manager senden ihre Information an einen Wrapper, welcher die Daten in das<br />
Format der Data Warehouse Tabellen wandelt und speichert. [vgl. Labio et al. (1997) S.<br />
557ff]<br />
- 57 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
5.4.2.2 DER SUMMARY TABLE ANSATZ<br />
Materialisierte Sichten in einem Data Warehouse können grundsätzlich auf zwei Arten<br />
aktualisiert werden. Entweder man erzeugt den materialisierten View komplett neu oder<br />
man arbeitet die Änderungen seit dem letzten Updatevorgang ein. Mumick et al. (1997)<br />
unterteilen dazu den Updatevorgang in einen Propagate Vorgang und einen Refresh<br />
Vorgang.<br />
Beim Propagate Vorgang werden so genannte Summary-Delta Tables erzeugt. Diese<br />
Tables enthalten alle Änderungen, welche sich seit dem letzten Updatevorgang ergeben<br />
haben. Man unterscheidet zwei Tables:<br />
• Den Pos_ins Table, welcher die neuen, bzw. veränderten Tupel des BFT enthält<br />
und<br />
• den Pos_del Table, welcher alle gelöschten Tupel enthält, welche aus dem BFT<br />
entfernt werden müssen.<br />
Beim Refresh Vorgang werden nun diese Änderungen der Delta-Summary Tables in die<br />
eigentlichen materialisierten Views geschrieben. Der Vorteil dieser Methode ist, dass<br />
während des Propagate Vorganges das Datawarehouse uneingeschränkt zur Verfügung<br />
steht, da die Abfragetabellen nicht berührt werden. Erst beim Refresh Vorgang ist das<br />
Warehouse nicht verfügbar. Dadurch kann die Gesamtzeit der Nichtverfügbarkeit<br />
deutlich gesenkt werden.<br />
Die Delta-Summary Methode funktioniert aber bei verschiedenen Aggregaten<br />
unterschiedlich. Mumick et al. (1997) unterscheiden grundsätzlich drei Klassen von<br />
Aggregaten:<br />
• Distributive (SQL Funktionen COUNT, SUM, MIN und MAX)<br />
• Algebraic (SQL Funktion AVG) und<br />
• Holistic (Median, …)<br />
Ein Nachteil der Delta-Summary Methode ist die Tatsache, dass nur distributive<br />
Funktionen verarbeitet werden können. Holistische Funktionen können grundsätzlich<br />
nicht verarbeitet werden. Algebraische Funktionen können zum Teil simuliert werden<br />
indem z.B. der Mittelwert aus Summe durch Anzahl berechnet wird (SUM/COUNT).<br />
Auch die Funktionen MIN und MAX sind nur eingeschränkt einsetzbar. Sollte z.B. das<br />
aktuelle MIN oder MAX Tupel in der Menge der gelöschten Tupel sein, ist es nicht<br />
möglich das neue MIN oder MAX Tupel zu bestimmen ohne den gesamten Table neu<br />
zu erzeugen. Dies kann zwar durch einen Algorithmus automatisiert werden, vermindert<br />
- 58 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
jedoch den Zeitgewinn, welcher durch die Delta-Summary Methode erzielt werden<br />
könnte.<br />
prepare-insertions prepare-deletions<br />
COUNT(*) 1 -1<br />
case when expr is null then case when expr is null then<br />
COUNT(expr)<br />
0 else 1<br />
0 else -1<br />
SUM(expr) expr -expr<br />
MIN(expr) expr expr<br />
MAX(expr) expr expr<br />
Tabelle 4: Änderungen der Aggregate nach Funktionen [Quelle: Mumick et al. (1997) S.105]<br />
In Tabelle 4 sind die Änderungen der Aggregattabellen abhängig von den jeweiligen<br />
Funktionen aufgelistet. Wird z.B. der Wert 10 im Delta Summary Insert Table<br />
errechnet, wird dieser Wert zum materialisierten View addiert. Wird z.B. der Wert 10<br />
im Delta Summary Delete Table errechnet, wird dieser Wert vom materialisierten View<br />
subtrahiert. [vgl. Mumick et al. (1997) S.100ff]<br />
5.4.2.3 DER MULTIPLE VIEW MAINTENANCE POLICIES ANSATZ<br />
Dieser Ansatz berücksichtigt, dass die Quelldaten, aus welchen die Daten importiert<br />
werden, sehr unterschiedlich sein können. Durch diese unterschiedliche Behandlung der<br />
materialisierten Views soll ein Perfomancegewinn erzielt werden. Dabei werden die<br />
Views in drei unterschiedliche Klassen eingeteilt:<br />
• Immediate Views: Diese können ständig aktualisiert werden, sobald sich eine<br />
Quelldatenbank, bzw. ein Quelldatensatz ändert.<br />
• Deferred Views: Diese Views werden bei Anfrage des Users materialisiert. Das<br />
führt zu langsameren Abfragen, aber schnelleren Update Vorgängen.<br />
• Snapshot Views: Diese werden periodisch durch einen asynchronischen Prozess<br />
aktualisiert. Dadurch ist die Aktualität der Daten nicht garantiert.<br />
Diese unterschiedlichsten Views können wiederum in Viewgroups zusammengefasst<br />
werden. Diese Viewgroups von Colby et al. (1997) sind definiert dass<br />
• die Aktualisierung eines Views in einer Viewgroup keine Aktualisierungen<br />
in einer anderen Viewgroup auslöst<br />
- 59 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
• es möglich sein muss, eine Query abzufragen ohne einen Join mit einem<br />
Table außerhalb der Viewgroup zu machen.<br />
[vgl. Colby et al. (1997) S.405ff]<br />
5.5 INFORMATIONSFLÜSSE IN EINEM DATA WAREHOUSE<br />
Connoly et al. (2002) teilen die Informationsflüsse in einem Data Warehouse in fünf<br />
primäre Informationsflüsse:<br />
Prozess Beschreibung<br />
Inflow Extrahieren, Laden und Reinigen der Quelldaten<br />
Upflow<br />
Erhöhen des Wertes der Daten im Warehouse durch<br />
Zusammenfassen, Verpacken und Verteilung<br />
Downflow Archivieren und Sichern der Daten im Warehouse<br />
Outflow Die Daten für Endbenutzer verfügbar machen<br />
Metaflow Verwalten der Metadaten<br />
Tabelle 5: Informationsflüsse im Data Warehouse [Quelle: Connolly et al. (2002) S. 918ff]<br />
5.5.1 INFLOW<br />
Der Inflow befasst sich damit, Daten aus den Quellsystemen zu übernehmen, die in das<br />
Data Warehouse geladen werden sollen. Da die Quelldaten überwiegend durch OLTP<br />
Systeme erzeugt werden, müssen sie für den Zweck des Data Warehouse neu aufgebaut<br />
werden. Dazu gehört Folgendes:<br />
• Reinigen der „verunreinigten“ Daten.<br />
• Neustrukturieren der Daten. Zum Beispiel durch Hinzufügen und/oder Löschen<br />
von Feldern und Denormalisierung.<br />
• Gewährleisten, dass die Quelldaten in sich und mit den bereits im Data<br />
Warehouse befindlichen Daten konsistent sind.<br />
Um den Inflow effizent zu verwalten, müssen Mechanismen festgelegt werden, um zu<br />
ermitteln, wann man mit dem Extrahieren der Daten beginnt, die erforderlichen<br />
Umwandlungen ausführt und Konsistenzprüfungen vornimmt. Beim Extrahieren der<br />
Daten aus dem Quellsystem muss man unbedingt dafür sorgen, dass sich die Daten in<br />
einem konsistenten Zustand befinden, um eine konsistente Ansicht der Firmendaten zu<br />
bekommen. Die Datenextraktionssoftware sollte vollständig automatisch funktionieren<br />
und in der Lage sein, das Auftreten von Problemen und Fehlern zu melden.<br />
- 60 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
5.5.2 UPFLOW<br />
Mit dem Upflow sind folgende Aktivitäten verknüpft:<br />
• Zusammenfassen der Daten durch Auswahl, Projezieren, Verknüpfen und<br />
Gruppieren relationaler Daten zu Ansichten, die für den Endbenutzer bequemer<br />
und hilfreicher sind. Das Zusammenfassen geht über einfache relationale<br />
Operationen hinaus - es umfasst ausgefeilte statistische Analysen einschließlich<br />
der Feststellung von Trends, der Clusterbildung und des Sampling.<br />
• Verpacken der Daten durch Konvertieren der zusammengefassten oder<br />
detaillierten Daten in sinnvollere Formen wie zum Beispiel Arbeitsblätter,<br />
Textdokumente, Diagramme oder Animationen.<br />
• Verteilung der Daten an geeignete Gruppen, um ihre Verfügbarkeit und<br />
Zugänglichkeit zu erhöhen.<br />
5.5.3 DOWNFLOW<br />
Die Archivierung alter Daten spielt bei der Aufrechterhaltung von Effizenz und<br />
Leistung des Data Warehouse durch Auslagern der älteren Daten eine wichtige Rolle.<br />
Der Informations-Downflow umfasst die Prozesse, welche sicherstellen, dass der<br />
aktuelle Zustand des Data Warehouse nach Datenverlust oder Soft- bzw.<br />
Hardwarefehlern wieder hergestellt werden kann.<br />
5.5.4 OUTFLOW<br />
Der Outflow ist die Stelle, an der die Organisation den wirklichen Wert des Data<br />
Warehouse wahrnimmt. Zum Outflow gehören folgende Schlüsselaktivitäten:<br />
• Das Zugreifen, das sich mit der Erfüllung der Anforderungen der Endbenutzer<br />
hinsichtlich der benötigten Daten befasst.<br />
• Das Übermitteln, das sich mit der aktiven Übermittlung der Information an die<br />
Rechner der Endbenutzer beschäftigt. Dies kann von periodischen Reports bis zu<br />
Veröffentlichungs- und Abonnementsprozessen reichen.<br />
5.5.5 METAFLOW<br />
Der Metaflow ist der Prozess, welcher Metadaten bewegt. Also Daten über die anderen<br />
Informationsflüsse. Um den sich ändernden Geschäftsbedürfnissen gerecht zu werden,<br />
ändern sich herkömmliche Systeme ständig. Der Metaflow muss sich deshalb<br />
fortlaufend mit diesen Änderungen befassen.<br />
- 61 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
5.6 PROBLEME IM DATA WAREHOUSE<br />
• Unterschätzen der Ressourcen für das Laden der Daten<br />
Viele Entwickler unterschätzen die für das Extrahieren, Reinigen und Laden<br />
der Daten in das Warehouse erforderliche Zeit, die bis zu 80% der<br />
Gesamtentwicklungszeit ausmachen kann, obwohl bessere Datenreinigungs-<br />
und Datenverwaltungswerkzeuge diese Zeit reduzieren könnten.<br />
• Unentdeckte Probleme mit Quellsystemen<br />
Unentdeckte Probleme im Zusammenhang mit den Quellsystemen, die das<br />
Data Warehouse speisen, werden irgendwann aufgedeckt, möglicherweise<br />
erst nach Jahren. Der Entwickler muss entscheiden, ob sie innerhalb des<br />
Data Warehouse und/oder in den Quellsystemen behoben werden sollen.<br />
Beim Eingeben der Einzelheiten können einige Felder beispielsweise eine<br />
NULL zulassen, was dazu führen kann, dass Mitarbeiter unvollständige<br />
Daten eingeben, obwohl diese verfügbar und geeignet sind.<br />
• Fehlende Aufzeichnungen der erforderlichen Daten<br />
Warehouse-Projekte zeigen häufig Bedarf für Daten, die in den bestehenden<br />
Quellsystemen nicht aufgezeichnet wurden. Die Organisation muss<br />
entscheiden, ob die operativen Systeme geändert werden oder ein System für<br />
die Aufzeichnung der fehlenden Information erstellt werden soll.<br />
• Gestiegener Bedarf für Endbenutzer<br />
Nachdem die Endbenutzer Abfrage- und Berichtswerkzeuge bekommen<br />
haben, kann die Anforderung von Unterstützung durch die für Dienste<br />
zuständigen Mitarbeiter steigen statt sinken. Das liegt am wachsenden<br />
Wissen der Benutzer über die Fähigkeiten und den Wert des Data<br />
Warehouse.<br />
• Datenhomogenisierung<br />
Data Warehousing in großen Umfang kann enorme Anforderung in Bezug<br />
auf die Datenhomogenisierung haben. Insbesondere ist darauf zu achten die<br />
Daten durch die Homogenisierung nicht zu verfälschen.<br />
• Hoher Ressourcenbedarf<br />
Das Data Warehouse kann viel Speicherplatz auf der Festplatte belegen.<br />
• Datenbesitz<br />
Sensible Daten sollten auch nach der Implementierung eines Data<br />
Warehouse nur gewissen Benutzern zugänglich sein.<br />
- 62 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
• Hoher Pflegeaufwand<br />
Data Warehouses sind Systeme mit hohem Pflegeaufwand, die oft in<br />
Kostenkalkulationen einen erheblichen Posten einnehmen können.<br />
• Projekte mit langer Dauer<br />
Der Aufbau eines Warehouse kann bis zu drei Jahre dauern. Dies wird oft<br />
unterschätzt und verursacht Komplikationen.<br />
• Komplexität der Integration<br />
Komplexe Unternehmensstrukturen führen zu komplexen Data Warehouse<br />
Systemen. Das stellt Entwickler oft vor unübersichtliche und nahezu<br />
unlösbare Fragestellungen.<br />
[vgl. Connolly et al. S. 912f]<br />
5.7 VORTEILE EINES DATAWAREHOUSE<br />
Als Vorteile eines effizienten und effektiven Informationsmanagements durch ein<br />
Datawarehouse lassen sich nach Fritz (1997) folgende Punkte herausstellen:<br />
• Reduzierung der Kosten für Entscheidungsprozesse:<br />
Durch Automatisierung der Datenbeschaffung und Datenkonsolidierung lassen<br />
sich redundante Informationsbeschaffung und langwierige Diskussionen über<br />
inkonsistente oder inkompatible Daten vermeiden. Gleichzeitig genügt es, den<br />
Mitarbeitern eine einzige Quelle für die Generierung von<br />
Managementinformationen zur Verfügung zu stellen.<br />
• Verbesserung der Qualität der Information:<br />
Durch die zentrale Speicherung von Daten aus unterschiedlichsten internen und<br />
externen Quellen wird es möglich, umfangreiche Analysen durchzuführen.<br />
Bisher nicht bekannte Zusammenhänge werden durch eine Integration der Data<br />
Mining Verfahren aufgedeckt.<br />
• Flexibilität der Informationsgewinnung:<br />
Neue Führungsinformationssysteme, die Data Warehouse- und Data Mining-<br />
Konzepte verbinden, können den Bedarf an Führungsinformationen besser<br />
befriedigen, denn sie sind auf die interaktive Informationsgewinnung ausgelegt<br />
und erleichtern die Interpretation der Daten. Im Gegensatz zu vorgefertigten<br />
Reports, wie sie von klassischen Management-Informationssystemen generiert<br />
wurden, bieten sie anwenderfreundliche, interaktive Analysemöglichkeiten.<br />
[vgl. Fritz (1997) S. 2]<br />
- 63 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
5.8 ANFORDERUNGEN AN EIN DATENBANKSYSTEM FÜR EIN<br />
DATAWAREHOUSE<br />
Die speziellen Anforderungen an ein für Data Warehousing geeignetes relationales<br />
Datenbanksystem sind nach Connolly et al. (2002):<br />
• Ladeleistung:<br />
Data Warehouses erfordern das regelmäßige inkrementelle Laden neuer Daten in<br />
engen Zeitfenstern. Die Leistung des Ladeprozesses sollte in hundert Millionen<br />
Zeilen oder in Gigabyte pro Sekunde gemessen werden, und das Geschäft sollte<br />
nicht durch eine Obergrenze eingeschränkt werden.<br />
• Ladeverarbeitung:<br />
Zum Laden neuer oder aktualisierter Daten in das Data Warehouse sind viele<br />
Schritte erforderlich: Datenkonvertierung, Filterung, Neuformatierung,<br />
Integritätsprüfung, physische Speicherung, Indizierung und Aktualisierung der<br />
Metadaten. Obwohl jeder Schritt in der Praxis atomar sein mag, sollte der<br />
Ladeprozess als geschlossene, nahtlose Arbeitseinheit erscheinen.<br />
• Sicherung der Datenqualität:<br />
Die Verlagerung auf faktenbasierte Verwaltung verlangt höchste Datenqualität.<br />
Das Warehouse muss trotz „unsauberer“ Quellen und gewaltiger<br />
Datenbankgrößen lokale und globale Konsistenz sowie referenzielle Integrität<br />
gewährleisten. Laden und Vorbereiten sind zwar notwendige Schritte, reichen<br />
aber nicht aus. Die Fähigkeit, die Abfragen der Endbenutzer zu beantworten,<br />
bildet den Erfolgsmaßstab einer Data Warehouse Anwendung. Mit der<br />
Beantwortung einer größeren Menge von Fragen neigen die Analysten dazu,<br />
kreative und komplexere Fragen zu stellen.<br />
• Abfrageleistung:<br />
Faktenbasierte Verwaltung und Ad-hoc-Analyse dürfen durch die Leistung des<br />
relationalen Data Warehouse Datenbanksystems weder gebremst noch<br />
verhindert werden. Umfangreiche, komplexe Abfragen für geschäftliche<br />
Schlüsseloperationen müssen in einem vernünftigen Zeitraum abgeschlossen<br />
werden.<br />
• Terabyte-Skalierbarkeit:<br />
Die Größe von Data Warehouse steigt enorm; sie beginnt bei wenigen oder<br />
mehreren hundert Gigabyte und erreicht mehrere Terabyte (10 12 Byte) oder<br />
Perabyte (10 15 Byte). Das relationale Datenbanksystem darf keine<br />
architekturbedingten Einschränkungen der Datenbankgröße aufweisen und sollte<br />
modulare und parallele Verwaltung unterstützen. Falls ein Fehler auftritt, sollte<br />
- 64 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
es fortlaufende Verfügbarkeit gewährleisten und Mechanismen für die<br />
Wiederherstellung bieten. Es muss Massenspeichergeräte wie optische Platten<br />
und Geräte zur hierarchischen Speicherverwaltung unterstützen. Die<br />
Abfrageleistung sollte schließlich nicht von der Größe der Datenbank, sondern<br />
von der Komplexität der Abfrage abhängen.<br />
• Benutzermengen-Skalierbarkeit:<br />
Das derzeitige Denken geht dahin, dass der Zugriff auf ein Data Warehouse auf<br />
relativ wenige Benutzer aus der Geschäftsleitung beschränkt ist. Das wird<br />
angesichts der Erkenntnis des Nutzens von Data Warehouses wahrscheinlich<br />
nicht so bleiben. Es lässt sich vorhersehen, dass das relationale<br />
Datenbanksystem für das Data Warehouse in Zukunft in der Lage sein sollte,<br />
mehrere hundert oder sogar tausend Benutzer zu verkraften und gleichzeitig eine<br />
akzeptable Abfrageleistung beizubehalten.<br />
• Das vernetzte Data Warehouse:<br />
Data Warehouse-Systeme sollten zur Zusammenarbeit in einem<br />
umfangreicheren Data Warehouse-Netzwerk fähig sein. Das Data Warehouse<br />
muss Werkzeuge zur Koordination der Bewegung von Datenteilmengen<br />
zwischen den Warehouses besitzen. Die Benutzer sollten von einer einzelnen<br />
Client-Workstation aus Einblick in mehrere Data Warehouses haben und mit<br />
diesen arbeiten können.<br />
• Warehouse-Administration:<br />
Der sehr große Umfang und die zeitzyklische Natur des Data Warehouse<br />
verlangt einfache und flexible Administration. Das relationale Datenbanksystem<br />
muss Steuerelemente besitzen, um Ressourcengrenzen, eine<br />
Rückbelastungskontierung (zur Zuweisung von Kosten an die Benutzer) und das<br />
Setzen von Prioritäten für Abfragen (zur Erfüllung der Bedürfnisse<br />
unterschiedlicher Benutzerklassen und Aktivitäten) implementieren zu können.<br />
Außerdem muss es die Verfolgung der Arbeitsbelastung und die<br />
Feinabstimmung vorsehen, damit sich die Systemressourcen auf maximale<br />
Leistung und maximalen Durchsatz optimieren lassen. Der am deutlichsten<br />
sicht- und messbare Wert für die Implementierung eines Data Warehouse zeigt<br />
sich im unbehinderten, kreativen Zugriff auf die Daten.<br />
• Integrierte dimensionale Analyse:<br />
Die Leistungsfähigkeit mehrdimensionaler Ansichten ist weithin akzeptiert, und<br />
um die höchstmögliche Leistung für relationale OLAP-Werkzeuge<br />
bereitzustellen, muss im relationalen Datenbanksystem des Warehouse<br />
dimensionale Unterstützung gegeben sein. Das Datenbanksystem muss das<br />
- 65 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
schnelle und einfache Erstellen im voraus berechneter Zusammenfassungen<br />
unterstützen, die in umfangreichen Data Warehouses üblich sind und<br />
Pflegewerkzeuge zur Automatisierung der Erstellung dieser Aggregatwerte<br />
bereitstellen. Die dynamische Berechnung von Aggregatwerten sollte mit den<br />
interaktiven Leistungsbedürfnissen des Endbenutzers übereinstimmen.<br />
• Erweiterte Abfragefunktionalität:<br />
Die Endbenutzer verlangen erweiterte analytische Berechnungen, sequenzielle<br />
und vergleichende Analysen und konsistenten Zugriff auf detaillierte und<br />
zusammengefasste Daten. Die Verwendung von SQL kann in einer<br />
Client/Server-Umgebung mit „Zeig-und-klick“-Werkzeugen wegen der<br />
Komplexität der Benutzerabfragen manchmal unpraktisch oder sogar unmöglich<br />
sein. Das relationale Datenbanksystem muss einen vollständigen und erweiterten<br />
Satz analytischer Operationen zur Verfügung stellen.<br />
[vgl. Connolly et al. (2002) S. 922f]<br />
5.9 DATA MARTS<br />
Zeitgleich mit dem Aufkommen der Data Warehouses entstand auch das verwandte<br />
Konzept der Data Marts. Ein Data Mart ist eine Teilmenge eines Data Warehouses,<br />
welche die Bedürfnisse einer bestimmten Abteilung oder Geschäftsfunktion erfüllt. Ein<br />
Data Mart enthält diese Teilmenge der Daten normalerweise in Form von<br />
zusammengefassten Informationen über eine bestimmte Abteilung oder<br />
Geschäftsfunktion. Der Data Mart kann selbständig oder zentral mit dem Data<br />
Warehouse verknüpft sein.<br />
Data Warehouses und Data Marts unterscheiden sich durch folgende Merkmale:<br />
• Ein Data Mart konzentriert sich ausschließlich auf die Bedürfnisse von<br />
Benutzern, die mit einer Abteilung oder Geschäftsfunktion zu tun haben.<br />
• Data Marts enthalten normalerweise im Unterschied zu Data Warehouses keine<br />
detaillierten operativen Daten.<br />
• Da Data Marts im Vergleich mit Data Warehouses weniger Information<br />
enthalten, sind sie einfacher zu verstehen, und man kann sich in ihnen leichter<br />
bewegen.<br />
[vgl. Connolly et al. (2002) S. 927f]<br />
- 66 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
5.10 DIE MODELLIERUNG EINES DATAWAREHOUSE<br />
5.10.1 MODELLTHEORIE<br />
Bei der Modellierung wird aus einem Problembereich, dem Original, durch Abbilden,<br />
Verkürzen und Vereinfachen mit einer gegebenen Pragmatik ein Modell gebildet. Man<br />
unterscheidet isomorphe (ohne Informationsverlust) und homomorphe (mit<br />
Informationsverlust) Abbildung von realen Systemen.<br />
Das Metamodell ist kein Modell eines Modells, sondern ein Modell eines<br />
Modellbereichs, d.h. einer Menge gleichartiger, nach der gleichen Technik erstellter<br />
Modelle. [vgl. Kaiser (2000)]<br />
Abbildung 18: Das Modellsystem [Quelle: Kaiser (2000)]<br />
Man unterscheidet drei Phasen der Modellierung:<br />
• Konzeptionelles Modell: z.B. Entity Relationsmodell, Dimensional Fact (DF)<br />
Modell<br />
• Umsetzung in ein logisches Modell: z.B. relationales Modell , Star Schema<br />
• Physischer Entwurf: Implementierung des konkreten Modells<br />
In jeder Phase der Modellierung stehen den Entwicklern unterschiedlichste Werkzeuge<br />
zur Verfügung.<br />
- 67 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
5.10.2 ATTRIBUTE<br />
Abbildung 19: Phasen der Modellierung [Quelle: Kaiser (2000)]<br />
Attribute stellen die Grundeinheiten für die Analyse dar. Attribute entsprechen in einer<br />
relationalen Datenbank den Spalten. Typische Attribute eines Kunden wären z.B.<br />
Kundennummer, Anrede, Name, Adresse, usw. In einem Data Warehouse unterscheidet<br />
man 3 Typen von Attributen:<br />
• Hierarchiestufen: Identifizieren ein Aggregationslevel (z.B. Kundengruppe,<br />
Region, Staat, usw.).<br />
• Schlüsselfelder, Indikator, „Fact-Attribute“: Sind Attribute, die aggregiert<br />
werden können (z.B. Umsatz, Stück, Liter, Kilogramm, usw.).<br />
• Nicht-aggregierbare Attribute: Sind Attribute, die zusätzliche Informationen<br />
geben (z.B. Name des Kunden, Adresse des Kunden, usw.).<br />
5.10.3 DIMENSIONEN UND HIERARCHIEN<br />
Die Dimension bestimmt die Granularität der . Sie ist ein meist symbolisches und<br />
diskretes Attribut, das die Auswahl, Zusammenfassung und Navigation eines<br />
Schlüsselfeldes erlaubt. Jede Dimension hat mindestens eine Hierarchiestufe. Man<br />
spricht von der Skalierbarkeit der Dimensionen (z.B. Tag, Monat, Jahr). Zu jeder<br />
Hierarchiestufe existiert eine konkrete Ausprägung (z.B. Staat, Land, Bezirk, Ort,<br />
- 68 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Strasse) und damit kann man für jede Hierarchiestufe eine Aggregation der Facts<br />
vornehmen (z.B. Umsatz pro Bezirk, Umsatz pro Ort, usw.).<br />
Abbildung 20: Einfache Hierarchie am Beispiel eines Kunden<br />
Die Zeit ist eine Dimension, die immer in jedem Data Warehousesystem vorkommt.<br />
Systeme mit mehr als zwei Dimensionen nennt man multidimensionale Systeme.<br />
Dimensionen und Hierarchien können relativ übersichtlich allgemein formal in der<br />
Notation d dargestellt werden. Wobei y im Intervall 0 → ∞ liegt und die Dimension<br />
x<br />
y<br />
repräsentiert. Die Variable x im Intervall 0 → ∞ gibt die Hierarchiestufe wieder. So<br />
stellt z.B. das Element<br />
5.10.4 DIE DATENWÜRFEL<br />
2<br />
d 3 die 3 Hierarchiestufe der Dimension 4 dar.<br />
Bei der Kombination von zwei Dimensionen entsteht eine klassische Tabelle, wie sie<br />
von dem relationalen Datenmodell her bekannt ist. Durch das Hinzufügen einer dritten<br />
Dimension entsteht ein dreidimensionaler Raum, der typischerweise in der Form eines<br />
Würfels (cube) modelliert wird. Jede Kante des Würfels bildet eine Dimension ab (siehe<br />
Abbildung 21) und ist durch deren Elemente in ihrer Länge fest skaliert. Wenn mehr als<br />
3 Dimensionen verwendet werden, spricht man auch von einem Hyper-Würfel<br />
(hypercube). Dabei ist zwar das geometrische Vorstellungsvermögen erschöpft,<br />
gedanklich aber sind mehr als dreidimensionale Kombinationen problemlos<br />
nachzuvollziehen, wenn die darin enthaltenen Dimensionen den realen Datenstrukturen<br />
entsprechen. Mathematisch kann ein Würfel mit n Dimensionen auch als Vektor (v) mit<br />
n Elementen aufgefasst werden, wobei jedes Element des Vektors einer Hierarchiestufe<br />
einer Dimension entspricht.<br />
- 69 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 21: Darstellung eines Würfels (cube) mit den Dimensionen Zeit, Artikel und Kunden [ in<br />
Anlehnung: Prosser/Ossimitz (2000), S. 18]<br />
5.10.5 OPERATOREN<br />
Würfel entstehen durch die Kombination von Dimensionen und deren Ausprägungen<br />
(Hierarchiestufen). Mögliche Inhalte ergeben sich aus dem Kartesischen Produkt der<br />
Hierarchiestufen . Bei z.B. 1000 Kunden und 5 Jahren über alle Artikel (Würfel X)<br />
erhält man 5000 mögliche Einträge für diesen Würfel. Diese Einträge enthalten die<br />
aggregierten Werte der Schlüsselfelder oder Facts (z.B. Summe Umsatz/Kunden und<br />
Jahr für alle Artikel). Es gibt aber neben der Summe noch eine Reihe andere<br />
Operatoren, die in Tabelle 6 kurz darstellt sind.<br />
Operator Nominal Ordinal Interval Rational<br />
Sum NO NO NO YES<br />
Average NO (YES) YES YES<br />
Minimum NO YES YES YES<br />
Maximum NO YES YES YES<br />
Tabelle 6: Operatoren und Zahlentypen [in Anlehnung: Prosser, Ossimitz (2000 a), S. 20]<br />
Nominale Kennzahlen sind durch Zahlen dargestellte Codewerte, wie etwa das<br />
Geschlecht oder klassische True-or-False-Aussagen (0 für männlich, 1 für weiblich).<br />
Diese Kennzahlen können nicht aggregiert werden und sind für Key Figures ungeeignet.<br />
- 70 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Ordinale Zahlentypen sind klassischerweise Ratings, wie etwa ein Schulnotensystem<br />
oder die Bewertung von Meinungsforschungsumfragen. Durch die ordinalen<br />
Kennzahlen wird nur eine Reihenfolge ausgedrückt, es wird jedoch keine Aussage über<br />
die Differenz zwischen den Werten gegeben. Deshalb kann normalerweise kein<br />
Mittelwert gebildet werden, obwohl das beim Schulnotensystem mit einer Kombination<br />
der Schulnoten mit einem gewissen Prozentsatz an richtigen Antworten zum Teil<br />
möglich ist. Intervallkennzahlen und Rationalkennzahlen sind beide metrisch. Der<br />
Unterschied liegt darin, dass Intervallkennzahlen einen Nullpunkt besitzen. Als<br />
bekanntestes Beispiel ist hier die Temperatur zu nennen. [vgl. Prosser/Ossimitz (2003) S. 32]<br />
5.10.6 SLICE AND DICE<br />
OLAP-Systeme bieten Anwendern individuelle und flexible Sichten auf „ihre“, für sie,<br />
interessanten Daten. Dies wird durch Isolieren einzelner Schichten aus dem gesamten<br />
Datenpool vollzogen. Slice beschreibt dabei das „Schneiden“ eines bestimmten<br />
Ausschnitts (etwa einer Periode) aus der Zeitdimension, wodurch der betrachtete<br />
Datenwürfel neu determiniert wird. Zum anderen besteht die Möglichkeit, diesen<br />
Würfel von verschiedenen Seiten zu betrachten. So erhält der Anwender durch<br />
„Drehen“, „Kippen“ oder „Würfeln“ (Dice) jeweils eine neue Perspektive. Mit Slice<br />
und Dice werden die Anwender bei typischen Geschäftsfragen unterstützt. (z.B. Welche<br />
Kunden im Burgenland haben einen Umsatz über 100 000 ?). [vgl. Schinzer et al. (1997), S.<br />
40 ]<br />
Abbildung 22: Selektion der Daten durch das Slice-Verfahren [Quelle: Schinzer et al. (1997), S. 40]<br />
- 71 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Die Abbildung 22 stellt deutlich die verschiedenen Möglichkeiten des Slice Verfahrens<br />
dar. Man sieht, dass unterschiedliche Anwender unterschiedliche Sichtweisen auf das<br />
Datenmodell benötigen.<br />
5.10.7 NAVIGATION DURCH DEN DATENBESTAND<br />
Beim Navigieren durch den Datenbestand unterscheidet man wie in Abbildung 23<br />
angeführt folgende Möglichkeiten:<br />
• Drill Down: Die Möglichkeit von hoch aggregierten Kennzahlen auf niedrigere<br />
Aggregationsstufen zu wechseln, um so zusätzliche Detailinformationen zu<br />
erhalten.<br />
• Roll up: Die Möglichkeit Kennzahlen niedriger Aggregationsstufe weiter zu<br />
aggregieren.<br />
• Drill Across (Drill Through): Die Möglichkeit bei einem beliebigen Schnitt<br />
durch den Datenwürfel auch die benachbarten Dimensionselemente (z.B. andere<br />
Region, anderer Kunden, anderes Produkt) zu betrachten.<br />
Abbildung 23: Die Navigation durch die Navigationsebenen [in Anlehnung: Prosser, Ossimitz (2000<br />
a), S. 24 ]<br />
- 72 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
5.10.8 KONZEPTIONELLE ODER SEMANTISCHE MODELLIERUNG<br />
5.10.8.1 GRAPHISCHE MODELLIERUNG<br />
Es gibt nicht viele Methoden ein Data Warehouse zu modellieren. Als eine der<br />
wichtigsten wird hier das Dimensional Fact (DF) Modell von Golfarelli, Maio und Rizzi<br />
genannt [vgl. Golfarelli et al. (1998)]. Dieses Modell besteht aus baumartigen „Fact-<br />
Schemas“, die aus Schlüsselfeldern, Dimensionen und Hierarchien bestehen.<br />
Hierarchie<br />
Monat<br />
ZEIT<br />
Tag<br />
Artikeltyp<br />
Artikel<br />
Verkauf<br />
Verkaufte Menge<br />
Umsatz<br />
Schlüsselfelder<br />
- 73 -<br />
Größe<br />
Kunde<br />
Nicht-aggregierbare<br />
Attribute<br />
Adresse<br />
Gruppe<br />
Abbildung 24: Einfaches Modell eines dreidimensionalen „Fact-Schema“ [in Anlehnung: Prosser,<br />
Ossimitz, (2000 a), S. 29]<br />
Die Modellierung mit dem „Fact-Schema“ beginnt mit der Auswahl der Facts<br />
(Schlüsselfelder, Kennzahlen), die für die Betrachtung interessant erscheinen. Danach<br />
wird für jedes Schlüsselfeld ein Attributbaum entwickelt (siehe Abbildung 25).
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 25: Attributsbaum vor Pruning und Grafting<br />
[in Anlehnung: Prosser, Ossimitz, (2000 a), S. 33]<br />
Dieser wird durch „Pruning“ und „Grafting“ vereinfacht. Der Zweck des „Pruning“ und<br />
„Grafting“ ist eine Vereinfachung des Modells. Beim „Pruning“ wird dabei ein<br />
kompletter Unterbaum vom Baum abgetrennt und aus der Betrachtung des „Fact-<br />
Schemas“ entfernt. Es ist natürlich dann auch unmöglich Daten dieses Unterbaumes zu<br />
aggregieren. Beim „Grafting“ werden nur einzelne Attribute, die uninteressante<br />
Information enthalten entfernt. In Abbildung 26 sehen sie wie durch „Grafting“ das<br />
Attribut „Rechnr“ entfernt wurde. Abschließend werden die Dimensionen, Hierarchien<br />
und „Fact-Attribute“ festgelegt.<br />
Abbildung 26: Attributsbaum nach Pruning und Grafting<br />
[in Anlehnung: Prosser, Ossimitz, (2000 a), S. 34]<br />
- 74 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
5.10.8.2 HALBGRAPHISCHE MODELLIERUNG<br />
5.10.8.2.1 GITTER<br />
Um eine systematische Planung der Datenwürfel durchführen zu können, benötigt man<br />
zuerst die Menge der möglichen Datenwürfel. Diese kann durch ein Gitter dargestellt<br />
werden. In Abbildung 27 sieht man ein Beispiel für ein Gitter mit 3 Dimensionen<br />
(Kunden, Artikel, Zeit). Die Dimensionen unterteilen sich in folgende Hierarchiestufen:<br />
• Kunden: Kunde individuell (K_id), Kundengruppe (K_gr), Kunden gesamt<br />
(K_*)<br />
• Artikel: Artikel individuell (A_id), Artikelgruppe (A_gr), Artikel gesamt (A_*)<br />
• Zeit: Tag (Z_t), Monat (Z_m), Jahr (Z_j), Zeit gesamt (Z_*)<br />
Abbildung 27: Gitter [in Anlehnung: Prosser, Ossimitz (2000 a), S. 40]<br />
Die Darstellung der Würfel in einem Gitter bringt viele Vorteile. Diese sind:<br />
• Jede Kombination der Hierarchiestufen der Dimensionen kann separat<br />
dargestellt werden<br />
• Man kann relativ leicht erkennen, welcher Würfel aus welchen Würfeln<br />
abgeleitet werden kann<br />
• Das Gitter zeigt alle Kombinationsmöglichkeiten<br />
• Das Gitter zeigt alle Kombinationsmöglichkeiten redundanzfrei.<br />
Der große Nachteil des Gitters ist jedoch, dass es relativ rasch mit steigender Anzahl der<br />
Dimensionen und Hierarchien zu komplex und unübersichtlich wird. [vgl.<br />
Prosser/Ossimitz (2001) S.55]<br />
- 75 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Allgemein ergibt sich die Größe eines Gitterverbandes aus<br />
Anzahl(Knoten)=∏ kn.....Anzahl der Hierarchiestufen in Dimension n<br />
k n<br />
n<br />
Für weiterführende Literatur zum Gitter siehe Crawley/Dilworth (1973).<br />
5.10.8.2.2 AGGREGATION PATH ARRAY<br />
Da das Gitter nicht für die Darstellung sehr komplexer mehrdimensionaler Strukturen<br />
geeignet ist, liegt es auf der Hand, eine Methode zu nutzen, welche die Vorteile des<br />
Gitters mit einer einfachen übersichtlichen Darstellung von anderen<br />
Modellierungsmethoden kombiniert. Das Ergebnis ist die von Prosser und Ossimitz<br />
entwickelte Methode des APA (Aggregation Path Array). Dieser Methode wurde unten<br />
der Abschnitt 6 gewidmet und wird dort entsprechend erläutert. Deshalb soll sie hier nur<br />
der systematischen Einordnung willen angeführt werden.<br />
5.10.9 LOGISCHE UND PHYSIKALISCHE MODELLIERUNG<br />
5.10.9.1 STAR-SCHEMA<br />
Das Star-Schema ist eine der bekanntesten Modellierungstechniken für ein Data<br />
Warehouse. Es besteht aus zwei Arten von Tabellen, dem „Fact-Table“ und dem<br />
Dimension-Table. Der Name Star-Schema rührt daher, dass die Dimension-Tables<br />
sternförmig um das zentrale „Fact-Table“ (Basisfaktentabelle) angeordnet sind. (siehe<br />
Abbildung 28). Die Anzahl der Tabellen entspricht immer der Summe von<br />
Dimensionen und dem „Fact-Table“.<br />
- 76 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 28: Star-Schema mit „Fact-Table“ (gelb) und vier Dimension-Tables<br />
[In Anlehnung: Prosser, Ossimitz (2000 a), S. 51]<br />
Zentraler Dreh- und Angelpunkt des Star-Schemas ist das „Fact-Table“. Es erfasst jede<br />
Transaktion in einer eigenen Zeile, wodurch es zur größten Tabelle des Schemas wird.<br />
Ein Dimensionselement jeder Dimension und mehrere numerische Kennzahlen<br />
(measures) stellen die Spalten des „Fact-Table“ dar, wodurch eine Transaktion<br />
eindeutig definiert wird. Anhand des Dimensionselements ist eine Verbindung zum<br />
entsprechenden Dimension-Table gewährleistet, entsprechend einem Primärschlüssel.<br />
Dort sind die verschiedenen Aggregationsstufen definiert, über die die Transaktionen<br />
des „Fact-Table“ konsolidiert werden können. [vgl. Schnizer et al., (1997), S. 48 f]<br />
Es gibt jedoch auch Nachteile des Star-Schemas. Es führt zu einem großen und teuren<br />
Bedarf an Plattenspeicher, hervorgerufen durch die Mehrfachspeicherung von<br />
Informationen. Große Dimension-Tables wirken sich sehr nachteilig auf die<br />
Performance aus. Aus diesem Grund wurde auch das Snowflake-Schema entwickelt.<br />
- 77 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 29: Das klassische Star-Schema [In Anlehnung: Prosser/Ossimitz (2000a ) S. 51]<br />
5.10.9.2 FACT CONSTELLATION-SCHEMA<br />
Beim klassischen Star-Schema kommt es bei großen Datenmengen zu<br />
Performanceproblemen. Besonders der große Base Fact Table bereitet Schwierigkeiten,<br />
da auch alle Aggregate im Base Fact Table gespeichert werden. Deshalb wurde das Fact<br />
Constellation-Schema entwickelt, welches eine Abänderung des Star-Schemas darstellt.<br />
Dabei werden die aggregierten Daten und die nicht aggregierten Daten separat<br />
gespeichert. Deshalb unterscheidet man Aggregated Fact Tables (AFT) für die<br />
Aggregate und den Basic Fact Table für die atomaren Daten.<br />
Als Vorteile des Fact Constellation Schemas ist folgendes zu nennen:<br />
• Das Level Attribut wird nicht mehr benötigt.<br />
• Die Performance ist bedingt durch die separate Speicherung der Aggregate<br />
verbessert.<br />
Als Nachteile des Fact Constellation-Schemas ist zu nennen:<br />
• Mit der Anzahl der Dimensionen steigt auch die Anzahl der AFT rapide an.<br />
Dadurch wird das Model sehr komplex und schwerer aufzubauen und zu warten.<br />
- 78 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
• Die Abfragen über mehrere Aggregate und/oder atomare Daten erfordert<br />
komplexere Joins.<br />
Im Fact Constellation-Schema sind die Dimensionstabellen nach wie vor<br />
denormalisiert. Dies kann bei großen Dimensionstabellen, welche viele Hierarchien<br />
enthalten, auch zu Performanceproblemen führen.<br />
[vgl. Prosser/Ossimitz (2001) S. 73ff]<br />
Abbildung 30: Das Fact Constellation-Schema [Quelle: Prosser/Ossimitz (2001) S. 76]<br />
5.10.9.3 SNOWFLAKE-SCHEMA<br />
Beim Snowflake-Schema, das eine Erweiterung des Star-Schemas darstellt, wird<br />
zusätzlich zur Normalisierung des „Fact-Tables“, eine Normalisierung der Dimension-<br />
Tables vorgenommen. Die Dimensionsattribute werden nicht mehr wie beim Star<br />
Schema in einer einzigen Tabelle pro Dimension gehalten, sondern es gibt für jedes<br />
Dimensionsattribut eine eigene Tabelle. In den Dimension-Tables stehen nur noch die<br />
Attributsschlüssel (z.B. MonatID), die auf die dazugehörigen Attribut-Tables<br />
verweisen.<br />
- 79 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 31: Snowflake-Schema mit Attribut-Tables<br />
[in Anlehnung: Prosser, Ossimitz (2000a), S. 62]<br />
Die Vorteile des Snowflake-Schemas liegen in der reduzierten Anzahl der zu<br />
bearbeitenden Zeilen – mit der entsprechenden Auswirkung auf die Performance – und<br />
in der Einsparung der Plattenkapazität. Nachteile liegen in der komplexeren<br />
Datenstruktur. [vgl. Schnizer et al. (1997) S. 50 f]<br />
5.10.9.4 GALAXY-SCHEMA<br />
Beziehen sich mehrere unterschiedliche Fakten auf die gleiche Dimensionen, wobei<br />
zwei Dimensionen genau dann gleich sind, wenn ihre komplexen und Basisobjekttypen<br />
gleich sind, dann wird eine Dimension mit den entsprechenden Fakten verbunden, da<br />
Dimensionen nicht redundant implementiert werden. Das durch derartige Verbindungen<br />
entstandene Schema wird Galaxy-Schema genannt. Ein Galaxy-Schema repräsentiert<br />
aus Sicht der OLAP-Anwendung eine Multicube-Architektur. Eine Multicube-<br />
Architektur ist dadurch gekennzeichnet, dass verschiedene Hypercubes gemeinsame<br />
Dimensionen haben. Die Abbildung 32 zeigt die Zusammenhänge zwischen Galaxy-<br />
Schema und Mulitcube-Architektur.[vgl. Rautenstrauch/Schulze (2003) S. 332]<br />
- 80 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 32: Galaxy-Schema und Multitube-Architektur<br />
[Quelle: Rautenstrauch/Schulze (2003) S. 334]<br />
5.10.9.5 DAS UNIMU-SCHEMA<br />
Das Unimu- Schema (Uniformes Datenschema für multidimensionale Daten) wurde an<br />
der Universität Leipzig entwickelt. Dabei wurde dieses Schema beim praktischen<br />
Einsatz in einem Energieunternehmen entwickelt. Dabei wurde in folgenden Schritten<br />
vorgegangen:<br />
• Uniformierung der Datenstruktur für die analyseorientierte Zusammenfassung<br />
dimensionsbezogener, betriebswirtschaftlicher Kennzahlen in einer Tabelle.<br />
• Zerlegung der Datenstruktur in eine Fakttabelle sowie je eine Tabelle für die<br />
(uniforme) Zeitdimension und die (uniforme) Objektdimension unter Nutzung<br />
des Star-Schemas.<br />
• Bildung einer Dimensionstabelle für Kennzahlen basierend auf dem Snowflake-<br />
Schema.<br />
• Hierarchische Verknüpfung von Dimensionspositionen durch die Ergänzung von<br />
Hierarchietabellen.<br />
Das Unimu-Schema basiert auf einer dreidimensionalen Modellierung<br />
betriebswirtschaftlicher Kenngrößen:<br />
• Zeitdimension: Jeder Fakt ist mit einer uniform verwendbaren Zeit_id versehen.<br />
Beliebige zeitbezogene Aggregate können somit in einer Fakttabelle abgelegt<br />
- 81 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
werden. Die zeitliche Dimensionierung kann individuell für alle Kombinationen<br />
von Kennzahl- und Objektdimensionen festgelegt werden.<br />
• Kennzahldimension: Die Kennzahlen werden in einer Dimension<br />
zusammengefasst. Neue Kennzahlen können so ohne Datenmodelländerung und<br />
Anpassung der Präsentationsanwendung hinzugefügt werden. Nicht sinnvolle<br />
Kombinationen von Kennzahlen und Objekten (z.B. Preis pro Produktgruppe)<br />
können ausgeschlossen werden. Die flexible Modellierung ist allerdings mit dem<br />
Nachteil einer umfangreichen Fakttabelle verbunden.<br />
Objektdimension: Durch die Modellierung erfolgt eine Trennung in logische und<br />
semantische Dimensionen. Semantische Dimensionen sind z.B. Kunden, Produkte und<br />
Regionen. Logische Dimensionen entsprechen oder ergeben sich aus der Verknüpfung<br />
semantischer Dimensionen (z.B. Kunden pro Region).<br />
Abbildung 33: Das Unimu-Schema [Quelle: Ehrenberg/Heine (1998) S. 507]<br />
Der große Vorteil des Unimu-Schemas ist, dass Dimensionen als Daten und nicht als<br />
Datenstrukturen verwaltet werden. Dadurch können neue Kennzahlen, neue<br />
Objektdimensionen und neue zeitliche Granularitäten ohne Schemaänderungen<br />
abgebildet werden.[vgl. Ehrenberg/Heine (1998) S. 503ff]<br />
- 82 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
6 DIE MODELLIERUNGSMETHODE AGGREGATION PATH<br />
ARRAY<br />
Die von Prosser und Ossimitz entwickelte Methode des APA (Aggregation Path Array)<br />
versucht die Modellierungsmethode des Gitters entsprechend zu verbessern. Dabei<br />
versucht man im Gitter nicht die gesamten Kombinationen der Dimensionen in ihren<br />
Hierarchiestufen darzustellen, sondern man gibt für jede Zelle im Gitter nur die<br />
geänderte Hierarchiestufe der Dimension (Attributsnamendarstellung) bzw. die<br />
Dimension, die sich geändert hat, an (Kurznotation). Deshalb ergibt jede Zeile alle<br />
möglichen Aggregationsschritte aller Dimensionen wieder. Es wird von Zeile zu Zeile<br />
nur die Reihenfolge der Aggregationsschritte verändert. Das führt jedoch zu<br />
Redundanzen zwischen den einzelnen Zeilen. Diese werden dann in einem zweiten<br />
Schritt entfernt bzw. ausgemerzt oder, wie in dem unten beschriebenen Algorithmus, in<br />
einem Schritt vollzogen. [vgl. Prosser/Ossimitz (2000b), S. 10 ff]<br />
In Abbildung 34 sieht man das analoge Beispiel des Gitters (siehe Abbildung 27) für ein<br />
APA mit 3 Dimensionen (Kunden, Artikel, Zeit).<br />
1 1 2 2 3 3 3<br />
1 1 2 3 3 3 2<br />
1 1 3 3 3 2 2<br />
1 2 2 3 3 3 1<br />
1 2 3 3 3 2 1<br />
1 3 3 3 2 2 1<br />
2 2 3 3 3 1 1<br />
2 3 3 3 2 1 1<br />
3 3 3 2 2 1 1<br />
K_gr K_* A_gr A_* Z_m Z_y Z_*<br />
K_gr K_* A_gr Z_m Z_y Z_* A_*<br />
K_gr K_* Z_m Z_y Z_* A_gr A_*<br />
K_gr A_gr A_* Z_m Z_y Z_* K_*<br />
K_gr A_gr Z_m Z_y Z_* A_* K_*<br />
K_gr Z_m Z_y Z_* A_gr A_* K_*<br />
A_gr A_* Z_m Z_y Z_* K_gr K_*<br />
A_gr Z_m Z_y Z_* A_* K_gr K_*<br />
Z_m Z_y Z_* A_gr A_* K_gr K_*<br />
Abbildung 34: Darstellung des APA des Praxisbeispiels in Kurznotation (links) und mit<br />
Attributsnamen (rechts) nicht redundanzfrei [in Anlehnung: Prosser, Ossimitz, (2000 a), S. 43]<br />
Die Dimensionen unterteilen sich in folgende Hierarchiestufen:<br />
• Kunden: Kunde individuell (K_id), Kundengruppe (K_gr), Kunden gesamt<br />
(K_*)<br />
• Artikel: Artikel individuell (A_id), Artikelgruppe (A_gr), Artikel gesamt (A_*)<br />
• Zeit: Tag (Z_t), Monat (Z_m), Jahr (Z_j), Zeit gesamt (Z_*)<br />
Dabei gibt jede Zelle, wie oben erwähnt, die Änderung einer Hierarchiestufe an.<br />
Allgemein beginnt jede Zeile mit den Dimensionen in der Ausgangshierarchiestufe 0<br />
- 83 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
0<br />
d 3 oder K_id, A_id, Z_d). In werterer Folge wird in jeder Spalte der Zeile für<br />
0 0<br />
( d 1 , d 2 ,<br />
eine weitere Dimension die Hierarchiestufe um eins erhöht bis in der letzten Spalte<br />
jeder Zeile die Endsituation mit allen Dimensionen in der höchsten Hierarchiestufe steht<br />
(z.B. d , d , d oder K_*, A_*, Z_*). So ergibt die markierte Zelle in Abbildung 34<br />
2<br />
1<br />
2<br />
2<br />
3<br />
3<br />
1 2 1<br />
die Kombination d 1 , d 2 , d 3 oder K_gr, A_*, Z_d. Jede Zelle im Gitter enthält aus<br />
Übersichtlichkeitsgründen nur die Hierarchiestufe, die im Vergleich zum Vorgänger<br />
links in derselben Zeile hochgezählt wurde. Damit kann man aber für jede Zelle relativ<br />
leicht den Würfel generieren, der dargestellt wird. Das geschieht indem man die höchste<br />
bis dahin in der Zeile links von der Zelle angeführte Hierarchiestufe der bereits<br />
zumindest einmal aggregierten Dimensionen nimmt und für die anderen Dimensionen<br />
die niedrigste Hierarchiestufe einsetzt. Für unseren markierten Würfel wäre somit die<br />
konkrete Ausprägung d , d , d oder K_gr, A_*, Z_d.<br />
1<br />
1<br />
2<br />
2<br />
0<br />
3<br />
Für die formale Definition des Permutationsalgorithmus [vgl. Prosser/Ossimitz (2000b), S<br />
12ff ], der zum Array in Abbildung 34 führt, benötigen wir zunächst die Definition eines<br />
Verschiebeoperators der folgenden Form: Gegeben sei ein Array von Zeilenvektoren,<br />
von denen alle dieselben Elemente dn, allerdings in einer anderen Reihenfolge<br />
beinhalten; ein Element dn kommt in einem Zeilenvektor nur einmal vor. Das Array<br />
bestehe zunächst nur aus einer Zeile: z1=(d1, d2, d3, ...., dn-1, dn). Wir bilden nun eine<br />
zweite Zeile und definieren dafür den Verschiebeoperator V der Form<br />
( d → d z − r)<br />
mit r ∈ N + , sodass die aktuelle Zeile z aus Zeile (z-r) abgebildet<br />
V a b<br />
wird, indem alle Elemente im Vektor vor da hinter db verschoben werden, die Elemente<br />
dazwischen um eine Position nach links aufrücken und alle Elemente, die ursprünglich<br />
nach db lagen, wieder unverändert bleiben. Damit erzeugt die Operation<br />
V d → d n − z −1)<br />
in Zeile z =2 den Vektor z2 = (d1, d3, ...., dn-1, d2, dn). Mit Hilfe diese<br />
( 2 1<br />
Verschiebeoperators kann nun folgendes Array gebildet werden:<br />
z =1<br />
i(<br />
1)<br />
1<br />
i(<br />
n−2)<br />
1 i(<br />
n−1)<br />
i(n<br />
)<br />
( d ,..., d ,..., d ,..., d , d ,..., d , d ,..., d )<br />
1<br />
1<br />
1<br />
n−2<br />
markiere Elemente<br />
n−2<br />
d ,..., d<br />
1<br />
1<br />
i(n<br />
)<br />
n<br />
n−1<br />
n−1<br />
/* Der Zähler für die Hierarchiestufen in Dimension n sei als k[n] bezeichnet, */<br />
/* wobei i(n)-k[n] die aktuell bearbeitete Hierarchiestufe in n bezeichnet; */<br />
k[1]=0<br />
do unitl i(1)-k[1]
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
do until i(2)-k[2] 0<br />
z ← z + 1<br />
V ( d<br />
markierte Elemente<br />
end if<br />
i(<br />
n−2)<br />
−k[<br />
n−2]<br />
n−2<br />
→ d<br />
k[<br />
n − 2]<br />
← k[<br />
n − 2]<br />
+ 1<br />
if i(<br />
2)<br />
− k(<br />
2)<br />
> 0<br />
V<br />
end if<br />
end do<br />
z ← z + 1<br />
i(<br />
n)<br />
n<br />
d<br />
z − ( i(<br />
n −1)<br />
+ 1)<br />
)<br />
1<br />
n−1<br />
, K,<br />
d<br />
i(<br />
n)<br />
in<br />
i(<br />
n−2)<br />
−k[<br />
n−2]<br />
i(<br />
n)<br />
( d → d z − ( i(<br />
n −1)<br />
+ 1)<br />
)<br />
n−2<br />
1 i<br />
markiere Elemente d , K,<br />
d<br />
k[<br />
2]<br />
← k[<br />
2]<br />
+ 1<br />
if i(<br />
1)<br />
− k[<br />
1]<br />
> 0<br />
z ← z + 1<br />
( n)<br />
n<br />
r n 1<br />
⎛ i(<br />
1)<br />
k[<br />
1]<br />
i(<br />
n)<br />
⎞<br />
V ⎜d<br />
d n z ( i(<br />
r)<br />
1)<br />
⎟<br />
⎜ 1 ← − ∏ +<br />
⎟<br />
⎝<br />
r 2 ⎠<br />
1 i(<br />
n)<br />
markierte Elemente d 2,<br />
, d n<br />
end if<br />
k[<br />
1]<br />
← k[<br />
1]<br />
+ 1<br />
end do<br />
− =<br />
−<br />
=<br />
K<br />
n<br />
3<br />
- 85 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
/* Die markierten v sind die redundanzfreie Menge v ∈ RF.*/<br />
procedure (inner_loop)<br />
/* Diese Schleife realisiert die Permutation der Dimensionen n und (n-1) */<br />
k[<br />
n −1]<br />
= 0<br />
do until k[<br />
n −1]<br />
= i[<br />
n −1]<br />
z ← z + 1<br />
V<br />
end do<br />
i(<br />
n−1)<br />
−k[<br />
n−1]<br />
i(<br />
n)<br />
( d → d z −1)<br />
n−1<br />
1 i<br />
markierte Elemente d , K,<br />
d<br />
k[<br />
n −1]<br />
← k[<br />
n −1]<br />
+ 1<br />
end _ procedure<br />
n<br />
n<br />
( n)<br />
n<br />
Der Verband in Abbildung 34 stellt aber die nicht redundanzfreie Kombination aller<br />
Dimensionen und Hierarchiestufen dar. Abbildung 35 stellt die redundanzfreie Menge<br />
des Praxisbeispiels durch farbliche Markierung dar.<br />
1 1 2 2 3 3 3<br />
1 1 2 3 3 3 2<br />
1 1 3 3 3 2 2<br />
1 2 2 3 3 3 1<br />
1 2 3 3 3 2 1<br />
1 3 3 3 2 2 1<br />
2 2 3 3 3 1 1<br />
2 3 3 3 2 1 1<br />
3 3 3 2 2 1 1<br />
K_gr K_* A_gr A_* Z_m Z_y Z_*<br />
K_gr K_* A_gr Z_m Z_y Z_* A_*<br />
K_gr K_* Z_m Z_y Z_* A_gr A_*<br />
K_gr A_gr A_* Z_m Z_y Z_* K_*<br />
K_gr A_gr Z_m Z_y Z_* A_* K_*<br />
K_gr Z_m Z_y Z_* A_gr A_* K_*<br />
A_gr A_* Z_m Z_y Z_* K_gr K_*<br />
A_gr Z_m Z_y Z_* A_* K_gr K_*<br />
Z_m Z_y Z_* A_gr A_* K_gr K_*<br />
Abbildung 35: Darstellung des APA des Praxisbeispiels in Kurznotation (links) und mit<br />
Attributsnamen (rechts) redundanzfreie Menge farblich markiert<br />
[in Anlehnung: Prosser, Ossimitz (2000 a), S. 43]<br />
Die redundanzfreie Menge aus einem fertig generierten Array, wie in Abbildung 35,<br />
erhält man, wenn man folgenden Algorithmus vollzieht:<br />
(1) Der Pfad in Zeile 1 des Array stellt alle Element das erste Mal dar und gehört somit<br />
gesamt zur redundanzfreien Menge.<br />
(2) Danach durchläuft man die nächste Zeile von links nach rechts und vergleicht jede<br />
Zelle mit der Zelle in der unmittelbar übergeordneten Zeile. Dieser Ablauf wird bis zum<br />
ersten Auftreten einer Ungleichheit der beiden Zellen durchgeführt, wobei all diese<br />
Zellen unmarkiert bleiben. Mit dem Auftreten der ersten Ungleichheit werden alle<br />
- 86 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
folgenden Zellen bis zum Auftreten der obersten Hierarchiestufe der letzten Dimension<br />
3<br />
(in diesem Fall das Element Z_* oder d 3 ) markiert. Alle Zellen rechts von dieser Zelle<br />
bleiben unmarkiert.<br />
(3) Punkt 2 wird für alle Zeilen bis zur letzten Zeile durchlaufen.<br />
Als Ergebnis sieht man die in Abbildung 35 dargestellte farblich markierte<br />
redundanzfreie Menge an Würfeln. Diese Menge gibt somit die vollständige und<br />
redundanzfreie Menge (i. e. sie enthält alle aus dem Basiswürfel ableitbaren Vektoren).<br />
Für einen Beweis siehe Prosser/Ossimitz (2000b) Anhang.<br />
Eine weitere im Data Warehouse Management entscheidende Frage ist, welche Würfel<br />
interessant für den Anwender und welche davon zu materialisieren sind. Hier ergibt sich<br />
ein Zielkonflikt zwischen der Performance (möglichst viele Würfel zu materialisieren,<br />
um schnelle Abfragen zu haben) und den Kosten für unnötige Datenhaltung und<br />
Prozessorarbeitsstunden. Das Finden einer optimalen Lösung, die ja von Anwender zu<br />
Anwender völlig verschieden sein kann, unterstützt das APA in relativ übersichtlicher<br />
Art und Weise. So könnte eine anwenderspezifische Anforderung für die interessanten<br />
Würfel lauten: „ Ich benötige einen Monatsbericht für alle Artikelgruppen mit einem<br />
kompletten Drill Down aller Artikel unabhängig von Kunden (a). Zusätzlich will ich für<br />
jeden individuellen Kunden einen Jahresbericht für alle Artikel haben (b).“<br />
Abbildung 36: Darstellung der interessanten Würfel<br />
[in Anlehnung: Prosser, Ossimitz (2000 b), S. 17 ]<br />
Abbildung 36 stellt die Würfel, welche die Anforderungen erfüllen, getrennt nach<br />
Bereich a und Bereich b markiert, dar. Dies sind die Würfel, die für die Abfrage<br />
benötigt werden.<br />
- 87 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Zusätzlich stellt sich nun die Frage, welche Würfel nun tatsächlich physisch<br />
materialisiert werden sollen, da es aus Speicherplatzgründen in den seltensten Fällen<br />
möglich ist, alle interessanten Würfel zu materialisieren. Deshalb kann diese Frage<br />
nur beantwortet werden, wenn man die Derivate der einzelnen Würfel betrachtet.<br />
Das APA kann dabei zur Bestimmung der Derivate eines Vektors verwendet<br />
werden:<br />
/* Bestimme die Anzahl der Spalten des Arrays */<br />
∑<br />
max<br />
s i(<br />
n)<br />
= n<br />
/*Bestimme die Anzahl der Zeilen des Arrays */<br />
z<br />
max<br />
=<br />
∏ − = r n 1<br />
r=<br />
1<br />
( i(<br />
r)<br />
−1)<br />
/* Abarbeiten aller Zeilen bis zum Ende des Arrays in z max erreicht ist */<br />
z = 1<br />
dountil<br />
s = s<br />
z > z<br />
max<br />
do until s<br />
max<br />
, ende = 0<br />
= 0<br />
or ende<br />
= 1<br />
j(<br />
m)<br />
( array _ element(<br />
z,<br />
s)<br />
= d ∈v)<br />
if<br />
markiereZelle<br />
sin<br />
z<br />
ende = 1<br />
else s ← s −1<br />
end if<br />
end do<br />
z ← z + 1<br />
end do<br />
m<br />
Alle Zellen (=Vektoren) w, die markiert oder rechts der markierten Zelle ihrer Zeile im<br />
Array liegen sind Derivate von v, w ∈ A(v). A(v) ∩ RF wäre die redundanzfreie Menge<br />
an Derivaten. [vgl. Prosser/Ossimitz (2000b) S. 18f ]<br />
Zum Algorithmus: Zunächst werden Zeilen- und Spaltenanzahl in z max bzw. s max<br />
hinterlegt. Da nur auf Elemente im APA abgefragt wird, wird die unterste<br />
Hierarchieebene ignoriert. Dies ist aber sinnvoll, da sich aus der untersten immer alle<br />
anderen Hierarchiestufen der Dimensionen ableiten lassen – für die Herleitung der<br />
Derivatsmengen sind daher nur die Dimensionen mit einer Hierarchiestufe größer oder<br />
gleich 1 im Vektor entscheidend. Markiert wird von rechts kommend (Beginn bei s max )<br />
- 88 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
in jeder Zeile jene Zelle, in der das erste Mal ein Element aus v einer Stufe ≥ 1<br />
vorkommt. [vgl. Prosser/Ossimitz (2000b) S. 18]<br />
Wir gehen von dem in Abbildung 36 angeführten Beispiel aus und versuchen nun die<br />
Menge der zu materialisierenden Würfel abzuleiten. Dabei betrachten wir zuerst die<br />
Derivativmenge Bereich x des Würfels x (blau markiert). Wir sehen, dass zwar der<br />
Bereich a vollständig mit den Derivativen des Würfels x abgedeckt ist. Der Bereich b<br />
jedoch nicht aus dem Würfel x abgeleitet werden kann.<br />
Abbildung 37: Anzeigebeispiel der Derivative (Bereich x) des Würfels x<br />
[in Anlehnung: Prosser, Ossimitz (2000 b), S. 17]<br />
Abbildung 38: Anzeigebeispiel der Derivate (Bereich y) des Würfels y<br />
[in Anlehnung: Prosser, Ossimitz (2000 b), S. 17]<br />
- 89 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Genauso betrachten wir die Derivatsmenge (Bereich y) des Würfels y (blau<br />
markiert) in Abbildung 38. Dabei ist zu erkennen das der Würfel y zwar den Bereich<br />
b abdeckt, den Bereich a jedoch nicht tangiert. Damit ist es notwendig zumindest<br />
zwei Würfel zu materialisieren.<br />
Deshalb versuchen wir ein Materialisieren beider Würfel in Abbildung 39<br />
darzustellen. Die Gesamtderivatsmenge von Bereich x und Bereich y wird rechts<br />
von der dicken Linie dargestellt.<br />
Abbildung 39: Anzeigebeispiel der Derivate (Bereich x + y) der Würfels x und y<br />
[in Anlehnung: Prosser, Ossimitz (2000 b), S. 17]<br />
Im Moment gibt es für die Bestimmung der zu materialisierenden Würfel aus den<br />
interessanten Würfel keinen wissenschaftlich ausgereiften Algorithmus. Deshalb<br />
können die zu materialisierenden Würfel im Moment nur durch Austesten bestimmt<br />
werden. Dies soll sich durch die in Abschnitt 7 beschrieben Heuristik ändern.<br />
7 FORSCHUNGSSCHWERPUNKT UND ERGEBNISSE<br />
7.1 DAS GRUNDPROBLEM UND DER LÖSUNGSANSATZ<br />
Der zentrale Fokus beim Aufbau von Data Warehouse-Konzepten sollte auf den Nutzen<br />
für den Anwender gelegt werden. Aus diesem Grund ist neben dem leichten, intuitiven<br />
Zugang unbedingt besonderes Augenmerk auf hohe Flexibilität und Schnelligkeit bei<br />
der Bearbeitung von Endbenutzerabfragen zu legen. Durch die Bestimmung der<br />
richtigen zu materialisierenden Würfel, sollen diese Anforderungen befriedigt werden.<br />
- 90 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Das Grundproblem der Bestimmung der zu materialisierenden Würfel (materialized<br />
cubes) unter Betrachtung der Menge der interessanten Würfeln (required cubes), welche<br />
die benötigte Information enthalten, ist also ein Optimierungsproblem. Im einfachsten<br />
Fall, in welchem keine Restriktionen hinsichtlich Ladezeit zum Aufbau des Data<br />
Warehouse oder Speicherplatz bestehen, würden grundsätzlich die interessanten Würfel<br />
und die zu materialisierenden Würfel identisch sein. Das heißt alle benötigten Würfel<br />
würden auch physisch materialisiert. Damit wäre auch für den Benutzer die minimale<br />
Zugriffszeit auf die Information garantiert. Es kann sogar sinnvoll sein noch zusätzliche<br />
Würfel zu materialisieren, da sie die Materialisierungszeit nachfolgender Würfel<br />
minimieren.<br />
In der Praxis ist jedoch festzustellen, dass sowohl hinsichtlich des Speicherplatzes -<br />
wobei dieses Problem von Tag zu Tag an Bedeutung verliert, da die Kosten für Speicher<br />
im Zeitablauf rapide sinken - aber im besonderen hinsichtlich der Ladezeit der Daten,<br />
welche für das Data Warehouse veranschlagt werden muss, Begrenzungen gelten.<br />
Durch die immer stärker werdende multinationale Unternehmensführung wird es immer<br />
schwieriger die Zeit für die Generierung und die Updates der Daten in einem Data<br />
Warehouse zu planen. Das eigentliche Problem ergibt sich daraus, dass während des<br />
Updates oder Neuaufbaus des Data Warehouses der Zugriff auf dieses nicht möglich ist.<br />
Wurden bei nationalen Unternehmen diese Updates einfach während der Nacht erledigt,<br />
kann dies beispielsweise von einer weltweit operierenden Fluglinie, welche die Daten<br />
immer an einem bestimmten Punkt der Welt gerade benötigt, nur sehr schwer erledigt<br />
werden. So bleiben für diese Unternehmen oft nur Zeitbereiche von wenigen Stunden<br />
pro Woche oder Tag, um ihre Daten auf den neusten Stand zu bringen.<br />
Aus diesem Grund besteht ein Optimierungsproblem, welches sich aus Konflikt der<br />
schnellstmöglichen Abfragezeit und der schnellstmöglichen Aktualisierungs- bzw.<br />
Aufbauzeit ergibt. Für diese Problem einen Lösungsansatz zu finden stellt den Kern<br />
meiner Forschungsarbeit dar.<br />
7.2 DIE VORGEHENSWEISE<br />
Um das Problem angreifbar, modellierbar und damit erforschbar zu machen gehe ich<br />
von einigen Annahmen aus. Diese sind:<br />
• Bei verteilten Datenbanken, welche sich auf unterschiedlichen Servern weltweit<br />
befinden, kann die Zeit für das Abfragen und Speichern eines Cubes von Würfel<br />
zu Würfel total unterschiedlich sein. Diese Information steht dem Benutzer und<br />
auch dem Planer eines Data Warehouses oft gar nicht zur Verfügung. Deshalb<br />
gehe ich von einer durchschnittlichen Zugriffszeit pro Transaktion aus. Diese ist<br />
durch den Benutzer für jedes Data Warehouse individuell festzustellen (z. B.<br />
- 91 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
durch zufällige Abfrageprobeläufe) und als Berechnungsbasis in das von mir<br />
entwickelte Gleichungssystem, bzw. die Software einzugeben. Diese<br />
durchschnittliche Zugriffszeit kann sich natürlich im Zeitablauf ändern und<br />
somit auch zu Veränderungen im Aufbau des Data Warehouse Systems führen.<br />
• Es besteht ein linearer Zusammenhang zwischen den in den Cubes gespeicherten<br />
Daten. Wird zum Beispiel in einem Cube der Jahresumsatz in einer FLOAT<br />
Variablen mit 8 Byte gespeichert, ist der benötigte Speicherplatz in einem<br />
anderen Cube, in welchem der Monatsumsatz gespeichert wird zwölf mal so<br />
groß. Das mag in der Praxis nicht immer stimmen, da moderne<br />
Datenbankmanagementsysteme mit ihren Query Optimizern zumeist<br />
automatische Indizes erzeugen. Geht man aber von einem einfachen Modell aus<br />
sehr wohl. Diese Vereinfachung des Models ist jedoch zwingend notwendig um<br />
die Komplexität des Problems zu bereinigen und eine wissenschaftliche<br />
Untersuchung zu ermöglichen.<br />
• Es besteht ein linearer Zusammenhang zwischen der Anzahl der Tupel im Table<br />
der abzufragenden Datenbank und der Abfragezeit. Empirische Untersuchungen<br />
von Dunemann (2002) belegen diese Annahme, da eine sehr starke Korrelation<br />
zwischen diesen beiden Werten besteht.<br />
• Es besteht ein linearer Zusammenhang zwischen der Anzahl der Tupel in der<br />
Ergebnismenge einer GROUP BY Abfrage und der Abfragezeit der Query.<br />
Diese Annahme wird ebenfalls von Dunemann (2002) untermauert, welcher eine<br />
Korrelation festgestellt hat. Diese ist allerdings nicht so stark wie bei der<br />
Korrelation zwischen Anzahl der Tupel in der abzufragenden Datenbank und<br />
Abfragezeit. Eine genaue Beschreibung dieser Studie wird in Kapitel 7.5<br />
behandelt.<br />
7.3 ABGRENZUNG DER PHASEN DER BETRACHTUNG<br />
Beim Aufbau und beim Update eines Datawarehouse unterscheiden wir 3 verschiedene<br />
Phasen:<br />
• Phase des Aufbaus des BFT aus den operativen und externen Datenquellen<br />
• Aufbau der materialisierten Sichten aus dem BFT<br />
• Abfragen der Informationen aus dem BFT oder den materialisierten Sichten<br />
- 92 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 40: Abgrenzung der Phasen der Betrachtung<br />
In meinen Überlegungen gehe ich von einer abgeschlossenen ersten Phase aus. Das<br />
heißt der Aufbau des BFT aus operativen und externen Systemen muss in jedem Fall<br />
erfolgen und hat auf die Auswahl der zu materialisierenden Sichten keinen Einfluss.<br />
Deshalb wird diese Phase und die Zeit, welche für diese Phase benötigt wird, nicht in<br />
die Betrachtungen aufgenommen. In der zweiten Phase, in der die materialisierten<br />
Sichten erzeugt werden, besteht eine strikte Zeitbeschränkung, da bis zur neuen<br />
Aggregation die Würfel nicht zur Verfügung stehen, bzw. unrichtige Information<br />
enthalten. Die dritte Phase umfasst die Abfragen der Benutzer bis zum neuerlichen<br />
Aufbau des Warehouse. Dabei werden die Gesamtkosten der Abfragen in dieser Periode<br />
durch das Produkt der Abfragekosten mit den geschätzten Anzahl der Abfragen<br />
errechnet. Dadurch werden auch wichtige Cubes früher materialisiert, da Kosten<br />
eingespart werden können.<br />
- 93 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.4 VERWANDTE ALGORITHMEN IM<br />
PROBLEMZUSAMMENHANG<br />
In diesem Abschnitt versuche ich bestehende Algorithmen zu präsentieren, welche<br />
einen Beitrag zur Lösung der Problemstellung liefern können. Dabei versuche ich<br />
bestehende, in der Literatur erwähnte, Algorithmen möglichst detailliert zu beschreiben.<br />
Unsere Aufgabe besteht unter anderem darin eine gute Heuristik zur Bestimmung der zu<br />
materialisierenden Würfel zu finden. Um die Qualität dieser Heuristik zu bewerten<br />
bedarf es jedenfalls der Bestimmung der optimalen Lösung. Dies soll durch diese<br />
Algorithmen programmtechnisch umgesetzt und überprüft werden. Zusätzlich werden<br />
Auszüge dieser Algorithmen in den Heuristiken der Software verwendet.<br />
7.4.1 KÜRZESTE UND LÄNGSTE WEGE<br />
Im Problemkreis der kürzesten und längsten Wege versucht man ein reales System oder<br />
ein zu lösendes Problem durch Graphen darzustellen. Standardaufgaben der<br />
Graphentheorie in diesem Kontext sind die als „Single source path“-Problem bekannte<br />
Bestimmung aller kürzesten Wege von einem Knoten zu allen anderen und die<br />
Bestimmung kürzester Wege zwischen allen Knoten, auch als „All pairs shortest path“-<br />
Problem („Finde die mit den geringsten Kosten verbundene Möglichkeit, alle Punkte zu<br />
verbinden.“) bekannt. In der Praxis, sowie auch in dem von uns behandelten<br />
Problemkontext, werden als Weg die Kosten angesetzt und die Problemstellung von<br />
einem kürzesten Weg Problem in ein minimales Kostenproblem gewandelt.<br />
[vgl. Sedgewick (2002) S. 513f ]<br />
Durch den hierarchischen Aufbau der Dimensionen und Hierarchien können die<br />
materialisierten Würfel als Graphen ansehen werden (siehe auch Kapitel 5.10.8.2.1).<br />
Diese werden durch Kanten verbunden, welche die Materialisierungskosten von einem<br />
Aggregat einer niederen Hierarchiestufe auf ein Aggregat einer höheren Hierarchiestufe<br />
symbolisieren.<br />
7.4.1.1 BEGRIFFSBESTIMMUNGEN<br />
7.4.1.1.1 GRAPHEN<br />
Abstrakt fasst ein Graph D zwei Mengen zusammen: die Menge V der Knoten und die<br />
Menge E der Kanten. Wir schreiben D= (V,E). Eine Kante ist ein geordnetes Paar von<br />
Konten. In der Schreibweise (v,w) bezeichnet v den Anfangskonten und w den<br />
Endknoten der Kante. In der Veranschaulichung<br />
- 94 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 41: Graph mit zwei Knoten<br />
zeigt die Spitze des verbindenden Pfeils auf den Endknoten w. v hat die Bedeutung des<br />
Vorgängers (Parents) von w und w die des Nachfolgers (Derivative) von v. v und w<br />
werden als adjazent oder benachbart bezeichnet und die Kante (v,w) heißt inzident zu<br />
den beiden Knoten v und w. Kanten, die den Knoten v als Anfangsknoten haben, werden<br />
auch als Ausgangsknoten von v und solche, die den Knoten v als Endknoten haben, als<br />
Eingangskanten dieses Knotens bezeichnet. Ein Graph mit n Knoten hat im Maximum<br />
n 2 und im Minimum 0 Kanten. [vgl. Reß/Viebeck (2000) S. 364f]<br />
7.4.1.1.2 EINGANGS- UND AUSGANGSGRAD<br />
Als Grad eines Knotens eines Graphen bezeichnet man die Summe der Kanten, die den<br />
Knoten als Ausgangsknoten (ausgehende Kanten) oder als Endknoten (eingehende<br />
Kanten) haben. Die Anzahl der eingehenden Kanten heißt Eingangsgrad (indegree) und<br />
die Anzahl der ausgehenden Kanten Ausgangsgrad (outdegree) des Knotens. [vgl.<br />
Reß/Viebeck (2000) S. 365f]<br />
7.4.1.1.3 WEG, ZYKLUS<br />
Eine Folge von Knoten v1, v2, … vn heißt Weg (path) von v1 nach vn, wenn der Endpunkt<br />
der Kante (vi-1, vi) mit dem Anfangspunkt der Kante (vi, vi+1) für 1
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
bezeichnet. Die Knoten und Kantenwerte eines Graphen sind jeweils vom gleichen<br />
Datentyp. [vgl. Reß/Viebeck (2000) S. 366f]<br />
7.4.1.1.5 KLASSIFIZIERUNG VON GRAPHEN<br />
Zur Klassifizierung von Graphen führen Reß/Viebeck (2000) folgende Begriffe ein [vgl.<br />
Reß/Viebeck (2000) S. 363]:<br />
Ein Graph heißt<br />
• symmetrisch, wenn mit der Kante (v,w) immer auch die Kante (w,v) für alle<br />
Knoten v und w impiziert ist, d.h. in symmetrischen Graphen besteht eine<br />
Verbindung zwischen zwei Knoten immer in beiden Richtungen. Ein Beispiel ist<br />
ein Straßennetz, in dem Verkehr in beiden Richtungen möglich ist.<br />
• asymmetrisch, wenn die Existenz der Kante (v,w), v ≠ w , die Existenz der Kante<br />
(w,v) ausschließt. In asymmetrischen Graphen besteht somit eine Verbindung<br />
zwischen zwei verschiedenen Knoten immer nur in einer Richtung. Ein Beispiel<br />
ist ein Straßennetz, das nur Einbahnverkehr zulässt.<br />
• reflexiv, wenn jeder Knoten des Graphen mit sich selbst verbunden ist, wenn<br />
also (v,v) für alle v gilt.<br />
• irreflexiv, wenn die Existenz der Kante (v,v) für alle Knoten v ausgeschlossen<br />
ist.<br />
• transitiv, wenn aus der Existenz der Kanten (v,w) und (w,z) die Existenz der<br />
Kante (v,z) folgt. Eine typische transitive Relation ist v
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
• d(s,s) = 0<br />
• d(s,w) = min {d(s,v)+c(v,w)} für v ∈ V (w)<br />
wobei V(w) die Menge der<br />
Vorgängerknoten von w bedeutet.<br />
Es stellt sich die Frage, wie man eine Reihenfolge der Knoten finden kann, damit<br />
die Rekursion auch ausführbar wird. Eine Lösung dazu liefert der Algorithmus von<br />
Dijkstra. Für azyklische Graphen findet man eine Reihenfolge einfach durch<br />
topologisches Sortieren der Kanten. [vgl. Reß/Viebeck (2000) S. 403ff]<br />
7.4.1.2.1 ALGORITHMUS VON DIJKSTRA<br />
Dieser Algorithmus gilt für einen allgemeinen Graphen, er muss nicht azyklisch sein.<br />
Bei diesem Ansatz ist jeder der Knoten eines Graphen entweder ein innerer Knoten,<br />
Randknoten oder äußerer Knoten. Für die inneren Knoten ist bereits ihr kürzester<br />
Abstand zum Startknoten s bekannt. Randknoten sind Knoten, für die man einen Weg<br />
von s kennt, der aber noch nicht ein kürzester sein muss. Für äußere Knoten kennt man<br />
noch keinen von s ausgehenden Weg. Zu Beginn ist der Startknoten s, der von sich<br />
selbst den minimalen Abstand Null hat, der einzige innere Knoten und die direkten<br />
Nachfolgerknoten bilden die Menge der Randknoten. Alle anderen Knoten sind äußere<br />
Knoten. Die Menge der inneren Knoten wächst nun schrittweise von innen nach außen,<br />
indem unter allen Randknoten derjenige mit dem kürzesten Abstand von s als nächster<br />
innerer Knoten genommen wird. Seine Nachfolger werden, soweit sie bisher noch<br />
äußere Knoten sind, zu neuen Randknoten. Für Randknoten, die erneut erreicht werden,<br />
kann sich ein neuer, kürzerer Abstand von s ergeben, der dann den bisherigen kürzesten<br />
Weg ersetzt.<br />
Wir demonstrieren das Verfahren am Beispiel des folgenden Graphen und bestimmen<br />
die kürzesten Wege des Knotens a zu allen anderen Knoten.<br />
- 97 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 42: Bewerteter Graph [Quelle: Reß/Viebock (2000) S. 404]<br />
Im ersten Schritt wird a zum inneren Knoten und seine Nachfolgerknoten b, c und d<br />
werden zu Randknoten. Die verbleibenden Knoten e und f sind äußere Knoten. Unter<br />
den Randknoten hat c den minimalen Abstand von a und c wird somit zum nächsten<br />
inneren Knoten. Einen kürzeren Weg zu irgendeinem anderen Knoten kann es nicht<br />
geben, da dieser notwendigerweise über die Knoten b oder d gehen müsste und d und b<br />
von a aus keine kürzere Entfernung als c haben. Unter den bereits bekannten Wegen<br />
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<br />
merken diesen kürzeren Weg nach d. Der Knoten f wird als Nachfolger vom Knoten c<br />
zu einem Randknoten. Als nächsten inneren Knoten bestimmen wir den Knoten b, der<br />
unter den Randknoten dieses Schrittes den minimalen Abstand von a hat. Die weiteren<br />
Schritte sind aus der folgenden Tabelle ersichtlich.<br />
- 98 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Schrittfolge<br />
Knoten<br />
Innere Knoten<br />
Minimaler<br />
Abstand von<br />
s<br />
Knoten<br />
- 99 -<br />
Randknoten<br />
vorläufig<br />
minimaler<br />
Abstand von<br />
s<br />
Vorgänger<br />
äußere<br />
Knoten<br />
1 a 0 b 4 a e<br />
c 2 a f<br />
d 6 a<br />
2 a 0 b 4 a e<br />
c 2 d 5 c<br />
f 8 c<br />
3 a 0 d 5 c e<br />
c 2 f 7 b<br />
b 4<br />
4 a 0 f 6 d<br />
c 2 e 7 d<br />
b 4<br />
d 5<br />
5 a 0 e 7 d<br />
c 2<br />
b 4<br />
d 5<br />
f 6<br />
6 a 0<br />
c 2<br />
b 4<br />
d 5<br />
f 6<br />
e 7<br />
Tabelle 7: Berechnung der kürzesten Wege von einem Knoten in einem Graph zu allen anderen<br />
[Quelle: Reß/Viebeck (2000) S. 405]<br />
In der folgenden Implementation des Algorithmus von Dijkstra für einen bewerteten<br />
Graphen in Adjazenzlistendarstellung sehen wir die Arrays distance und parent, beide<br />
von der Länge D.GetNumVertices, vor. parent ist von Typ VPostition und distance vom<br />
Typ float. Für einen Knoten v mit der Ordnungsnummer i zeigt parent[i]!=NULL auf<br />
den Vorgängerknoten, der auf dem zuletzt durchlaufenen Weg zum Knoten v liegt. Und<br />
enthält distance[i] die bisher für v ermittelte Entfernung vom Startknoten. Die<br />
Initialwerte sind parent[i]=NULL und distance[i]=0. Am Schluss weist distance[i] den<br />
kürzesten Weg des Kontens v vom Startknoten s aus. Die Gewichte liegen als float-<br />
Werte in den jeweiligen Kanten vor.<br />
Für die Speicherung der Randknoten ist eine Prioritätswarteschlange am geeignetsten.<br />
Jeder Record der Schlange merkt einen Randknoten und dessen bisher ermittelten<br />
Abstand vom Startknoten. Die Records seien Objekte der Klasse PriorityRecord. Wir<br />
interpretieren den Abstand als Schlüssel (Priorität) und den Randknoten (Typ
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
VPosition) als zugehörigen Wert eines solchen Records und führen die<br />
Prioritätswarteschlange als Objekt PriorityQueue ein. Die Operation FindMin der<br />
Klasse PriorityQueue liefert den Record mit dem minimalen Prioritätswert, d.h. dem<br />
kürzesten Abstand vom Startknoten. Die Elementfunktionen GetVertex() und GetKey()<br />
der Klasse PriorityRecord bestimmen in einem Record dieses Typs den Randknoten<br />
und seine bisherige kürzeste Entfernung vom Startknoten. Zu Beginn wird die<br />
Prioritätswarteschlange durch einen ersten Eintrag für den Startknoten s mit dem<br />
Abstandswert NULL initialisiert.<br />
Das Programm Dijkstra entnimmt in einer äußeren Schleife den jeweils nächsten<br />
Eintrag aus der Prioritätswarteschlange. Dieser bezeichnet unter allen Randknoten<br />
denjenigen mit dem kürzesten Abstand zum Startknoten und er wird zum nächsten<br />
inneren Knoten v. In einer inneren Schleife werden dann nacheinander für die Kanten a<br />
des Knotens v der jeweilige Endknoten w bestimmt, für den dann aus dem Abstandswert<br />
des Knotens v, erhöht um den Wert der Kante a, seine Entfernung vom Startknoten<br />
bestimmt wird. Ist w bisher noch unbesucht, wird für ihn ein Eintrag in der<br />
Prioritätswarteschlange mit dem ermittelten Abstandswert vorgenommen. Ist w aber<br />
bereits Randknoten, so werden im Fall eines neuen kürzeren Abstands vom Startknoten<br />
die Werte distance und parent des Knotens sowie die Priorität in der Warteschlange<br />
entsprechend fortgeschrieben.<br />
Void Dijkstra(Graph &D,<br />
VPostitions)<br />
//berechnet die kürzesten Wege in D vom Knoten s<br />
aus<br />
{<br />
int n=D.GetNumVertices(),i,j; //Anzahl<br />
Knoten<br />
PriorityQueueq(n);<br />
//Prioritätswarteschlangen für<br />
Randknoten<br />
VPosition
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
//Speicherplatz für Array distance und<br />
parent<br />
float distv, dista, distw,distnew;<br />
Ord(D); //Ordnungsnummer Knoten generieren<br />
NotVisited(D); //Knoten unbesucht markieren<br />
For (i=0; i
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
}<br />
dista=D.GetArc(a); //Abstandswert der<br />
Kante a<br />
distnew=distv+dista; //neue Entfernung<br />
von s für w<br />
if (!D.IsVisited(w))<br />
{<br />
}<br />
//neuer Randknoten<br />
p=new PriorityRecord(w,distnew);<br />
q.Insert (*p); //neuer Randknoten<br />
D.SetVisited(w,true); //Knoten w<br />
besucht<br />
Parent[j]=v; //v ist der Vorgänger<br />
von w<br />
distance[j]=distnew;<br />
//bisherige kürzeste Entferung von<br />
s für w<br />
else //w bereits Randknoten<br />
if (distw>distnew)<br />
{ //neue kürzeste Entfernung für w von<br />
s<br />
}<br />
p=new PriorityRecord(w,distw);<br />
//Suchargument<br />
q.DecreasePriority(*p,distnew);<br />
//neuen kürzesten Abstand für w in<br />
q eintragen<br />
distance[j]=distnew;<br />
//neue kürzeste Entferung<br />
parent[j]=v; //neuer Vorgänger<br />
a=D.NextArc(v,a); //nächste Kante für<br />
Knoten v<br />
- 102 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
}<br />
}<br />
Die Prioritätswarteschlange nimmt, da jeder ihrer Records nur einen Knoten enthält,<br />
insgesamt n = V Records auf. Bei der Zeitanalyse für die Prioritätswarteschlange ist<br />
dann von n Insert- und n DeleteMin-Operationen auszugehen. Die innere Schleife wird<br />
für jede der e = E Kanten des Graphen ausgeführt. Dabei wird höchstens eine Insert-<br />
oder eine IncreasePriority-Operation ausgeführt. Bei Implementation der<br />
Prioritätswarteschlange als Heap kostet jede dieser Operationen O (logn)<br />
. Der Aufwand<br />
für den Algorithmus ist somit von der Ordnung O (( n + e)<br />
log n)<br />
.<br />
7.4.1.2.2 ALGORITHMUS VON BELLMANN-FORD<br />
Dijkstras Algorithmus funktioniert nur, wenn die Kantengewichte keine negativen<br />
Werte annehmen können. Dies kann man sich leicht daran verdeutlichen, dass eine lokal<br />
ungünstige nächste Kante durch eine darauf folgende negativ gewichtete Kante<br />
nachträglich zu einer besseren Verbindung führt. Dies kann zum Beispiel für Graphen<br />
die Gewinne und Verlust abbilden sollen, aber zu falschen Ergebnissen führen. Deshalb<br />
wurde der Algorithmus von Bellmann-Ford entwickelt. Dieser funktioniert nach einem<br />
komplett anderen Prinzip: In mehreren Durchläufen wird jeweils die beste bisher<br />
mögliche Verbindung bestimmt, wobei der i-te Durchlauf alle Pfade der Länge i<br />
berücksichtigt. Der längste Pfad ohne Zyklus hat eine Länge von E −1<br />
, so dass man<br />
diesen Prozess nach E −1<br />
Durchläufen abschließen kann. Als Optimierung kann man<br />
das Verfahren vorzeitig beenden, wenn in einem Durchlauf keinerlei Änderungen zur<br />
vorherigen Wertebelegung mehr aufgetreten ist.<br />
Algorithm BF(G,s)<br />
//ein Graph G mit einem Startknoten s//<br />
D[s]:=0;<br />
For i:=1 to E −1<br />
do<br />
For each ( u, v)<br />
∈ E do<br />
//gerichtete Kanten//<br />
if D [ u]<br />
+ γ (( u,<br />
v))<br />
< D[<br />
v]<br />
then<br />
fi<br />
D[ v]<br />
: = D[<br />
u]<br />
+ γ (( u,<br />
v))<br />
- 103 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
od<br />
od<br />
[vgl. Saake/Sattler (2002) S. 427ff]<br />
7.4.1.2.3 KÜRZESTE WEGE FÜR EINEN AZYKLISCHEN GRAPHEN<br />
Der folgende Absatz soll den oben beschriebenen Algorithmus umgelegt auf einen<br />
azyklischen Graphen, welcher in unserer Problemstellung auftritt, zeigen. Damit wird<br />
versucht das Problem und die Lösungsmöglichkeiten näher zu fokussieren.<br />
Wir führen die Rekursion<br />
d ( s,<br />
s)<br />
= 0<br />
d( s,<br />
w)<br />
= min{ d(<br />
s,<br />
v)<br />
+ c(<br />
v,<br />
w)}<br />
für v ∈V<br />
( w)<br />
mit den topologisch sortierten Knoten direkt aus. Für Graphen der Abbildung 42 bildet<br />
die Folge der Knoten<br />
a – c – b – d – f – e<br />
eine topologische Ordnung. Wir nehmen den ersten Knoten der Ordnung als<br />
Startknoten.<br />
Schrittfolge Knoten v<br />
Vorläufiger<br />
minimaler<br />
minimaler<br />
Abstand<br />
Nachfolger w Abstand<br />
Knoten w von<br />
Knoten w von<br />
s<br />
s<br />
1 a c 2 2<br />
b 4<br />
d 6<br />
2 c b 4 4<br />
d 5<br />
f 8<br />
3 b d 5 5<br />
f 7<br />
4 d e 7 6<br />
f 6<br />
5 f e 7 7<br />
6 e<br />
Tabelle 8: Berechnung der kürzesten Wege für einen azyklischen Graphen<br />
[Quelle: Reß/Viebeck (2000) S. 408]<br />
Die Knoten werden nacheinander in topologischer Ordnung betrachtet und es wird<br />
sofort ihre kürzeste Entfernung vom Startknoten s bestimmt. Das Ergebnis zeigt Tabelle<br />
8. Das Programm ShortestPath ermittelt wie das Programm Dijstra die kürzeste<br />
Entfernung eines Knotens v vom Startknoten s sukzessive in der Arrayvariablen<br />
distance[i], i bezeichnet die Ordnungsnummer des Knotens v. Der Initialwert für<br />
distance[i] ist 0; die Bedingung dafür ist !D.IsVisited(v). Immer dann, wenn sich durch<br />
- 104 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Hinzunahme des nächsten Knotens ein kürzerer Abstand von s ergibt oder sich in<br />
distance[i] noch der Initialwert befindet, wird der bisherige Wert durch den neuen<br />
ersetzt. Die Knoten werden in Folge ihrer topologischen Ordnung berechnet. Zum<br />
Schluss stehen im Array distance für alle Knoten des Graphen die kürzesten vom<br />
Startknoten s ausgehenden Wege. Die Laufzeit des Programms ist O ( n * e)<br />
.<br />
Void ShortestPath(Graph &D)<br />
{<br />
unsigned n=D.GetNumVertices(),i,j;<br />
VPositionv,w;<br />
APositiona;<br />
VPosition*ord=new<br />
VPosition[n];<br />
//Knoten in Sortierordung<br />
float *distance=new float[n];<br />
//bisher kürzeste Abstände<br />
float dista,distnew;<br />
TopSort(D); //topologisches Sortieren<br />
NotVisited(D); //Knoten unbesucht<br />
v=D.FirstVertex(); //Initalisieren Arraywerte<br />
while (v.Pos())<br />
{<br />
}<br />
i=D.GetOrd(v); //Sortierindex Knoten v<br />
ord[i]=v; //Knoten v in Array ord<br />
distance[i]=0;<br />
v=D.NextVertex(v);<br />
for (i=0; i
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
}<br />
}<br />
{<br />
}<br />
w=D.Endpoint(a); //Endpunkt w der<br />
Kante a<br />
j=D.GetOrd(w); //Index vom Endknoten<br />
dista=D.GetArc(a); //Wert dista von<br />
Kante a<br />
distnew=distance[i]+dista;//Entfernung<br />
w von s<br />
if (!D.IsVisited(w))<br />
{//Knoten noch unbesucht<br />
}<br />
else<br />
D.SetVisited(w,true); //Konten<br />
besuchen<br />
distance[j]=distnew; //Entfernung<br />
setzen<br />
if (distnew
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Kostenmatrix C 0[<br />
i,<br />
j]<br />
wird dieser Prozess so lange wiederholt, bis sich die Matrix nicht<br />
mehr ändert. Die letzte Matrix enthält dann die kürzesten Wege zwischen je zwei<br />
Knoten von D.<br />
Für 0<br />
C gilt: ] , [ C i j = 0 und C [ i,<br />
j]<br />
= ∞ , falls keine Kanten von vi nach vj existiert.<br />
0<br />
0<br />
Beim Übergang von Ck− [ i,<br />
j]<br />
nach Ck [ i,<br />
j]<br />
sind zwei Fälle zu unterscheiden:<br />
1<br />
Es wurde noch kein Weg von vi nach vj festgestellt, d.h. Ck− 1[<br />
i,<br />
j]<br />
= ∞ . Gibt es einen<br />
Weg von vi nach vk und einen Weg von vk nach vj, so führt auch ein Weg von vi nach vj .<br />
Es wird Ck [ i,<br />
j]<br />
= Ck− [ i,<br />
k]<br />
+ [ k,<br />
j]<br />
.<br />
1<br />
Ck− 1<br />
Abbildung 43: Darstellung der Knoten und Kanten<br />
Es existiert ein Weg von vi nach vj , d.h. [ i,<br />
j]!<br />
= ∞ , und ein weiterer, der über vk<br />
H k − 1<br />
führt und kürzer ist. Dann wird Ck [ i,<br />
j]<br />
= Ck− [ i,<br />
k]<br />
+ [ k,<br />
j]<br />
.<br />
1<br />
- 107 -<br />
Ck− 1<br />
Der Algorithmus von Floyd setzt die Kostenmatrix des Graphen voraus. Das Zeichen ∞<br />
wird durch die größte Zahl des Datentyps der Kantenwerte simuliert.<br />
void Floyd(Graph &D)<br />
{<br />
int n=D.GetNumVertices(),i,j=0,k;<br />
int iter=1;<br />
float C=new float[n*n],h;<br />
boolean b;<br />
D.CostMatrix(C); //Initialisierung<br />
for (i=0;i
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
}<br />
}<br />
for (i=0;i
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Statement nur beschrieben wird, welche Daten der Benutzer bzw. das<br />
Anwendungsprogramm vom Datenbanksystem geliefert haben möchte. Es wird in<br />
keinem Fall im SQL-Statement beschrieben, wie das Datenbanksystem diese Daten<br />
finden soll. Dies ist die Aufgabe eines so genannten Zugriffs-Optimierers oder englisch<br />
Query Optimizer.<br />
Da in der entwickelten Software für die Planung des Aufbaues eines Datawarehouse mit<br />
Microsoft SQL eine relationale Datenbank als Basis definiert wurde, sind die Kosten für<br />
die Abfrage ein Punkt, welcher beleuchtet werden muss. Dabei soll es meiner Software<br />
möglich sein, durch die Eingaben des Benutzers näherungsweise Aussagen über die<br />
benötigte Zeit der Abfrage zu liefern. Die Kalkulation dieser Kosten wird im Normalfall<br />
vom Query Optimizer durchgeführt. Leider veröffentlichen Datenbankhersteller die<br />
Kostenfunktionen, bzw. die Funktionalität dieser Query Optimizer nicht, da die<br />
Performance eines Datenbankmanagementsystems im entscheidenden Maße von der<br />
Arbeitsweise des jeweiligen Optimizers abhängt. Im Gegenteil, die Funktionen und<br />
Arbeitsweise des Query Optimizers werden von den Datenbankherstellern als<br />
Betriebsgeheimnis angesehen. [vgl. Müller-Angstenberger (1994) S. 1]<br />
Durch diese Geheimhaltung sind in der Literatur nur grobe Schätzverfahren über die<br />
Kosten, bzw. die Abfragezeit einer Abfrage vorhanden. Diese zum Teil sehr<br />
unterschiedlichen Ansätze will ich nun vorstellen.<br />
Heuristische Optimierungstechniken sind darauf ausgerichtet, in der Mehrzahl der Fälle<br />
innerhalb kurzer Laufzeit gute Ergebnisse – d.h. nahezu optimale<br />
Anfrageauswertungspläne – zu liefern. Ein Kostenmodell stellt Funktionen zur<br />
Verfügung, die den Aufwand, d.h. die Laufzeit, der Operatoren der physischen Algebra<br />
abschätzen. Dazu werden diverse Parameter wie Indexe, Ballungen, Kardinalitäten und<br />
Verteilungen benötigt. [vgl. Kemper/Eickler (1996) S. 211f]<br />
Abbildung 44: Funktionsweise eines Kostenmodells [Quelle: Kemper/Eickler (1996) S. 212]<br />
- 109 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Grundsätzlich muss entschieden werden, ob die Daten sequentiell oder über einen Index<br />
gesucht werden sollen. Voraussetzung für einen Indexzugriff ist selbstverständlich das<br />
Vorhandensein eines geeigneten Index. Stehen für den Zugriff prinzipell mehrere<br />
Alternativen zur Auswahl, so wird der Optimizer abschätzen, welche Zugriffsmethode<br />
die günstigere, d.h. die kostengünstigere ist. Dazu dient laut Müller-Angstenberger<br />
(1994) folgende Formel:<br />
Kosten des Zugriffs = X * Anzahl IOs + Y * CPU Verbauch<br />
Dieses grobe Modell besagt, dass pro Zugriff die Kosten der zu erwartenden IOs sowie<br />
die Kosten des zu erwartenden CPU Verbrauchs geschätzt und gewichtet werden. Das<br />
Ergebnis sind die geschätzten Gesamtkosten. [vgl. Müller-Angstenberger (1994) S. 2]<br />
Die Kosten aller Zugriffe ergeben sich somit aus der Summe der Einzeloperationen. Das<br />
gewählte Maß kann, bevor die Anfrage tatsächlich ausgeführt worden ist, nur geschätzt<br />
werden. Eine exakte Bestimmung setzt die Durchführung der Anfrage voraus, da nur<br />
dadurch die getroffenen Annahmen über die Verteilung der Daten auf dem<br />
Sekundärspeicher überprüft werden können. Ein solches Maß ist laut Dunemann (2002)<br />
„die Anzahl der Festplattenzugriffe, da anzunehmen ist, dass dieser Wert mit der<br />
Gesamtlaufzeit der Anfrage korreliert. Hierzu wird zum einen unterstellt, dass<br />
Verarbeitungen im Hauptspeicher so schnell ablaufen, dass sie einen vernachlässigbar<br />
geringen Anteil an der Beantwortungszeit der Anfrage ausmachen. Zum anderen wird<br />
bei einer Anfrage angenommen, dass das Ergebnis nicht wieder auf die Festplatte<br />
geschrieben wird, sondern von einer Applikation konsumiert wird. Somit kann für die<br />
Kostenschätzung auf die Eigenschaften der Eingangsdatenmengen abgestellt werden,<br />
während die Form des Ergebnisses nur für die Kosten der nachfolgenden Operationen<br />
relevant ist.“ [vgl. Dunemann (2002) S. 56]<br />
Einen ähnlichen Ansatz finden Harinarayan et al. (1996), welche die Abfragezeit als<br />
proportional zur Anzahl der Zeilen ansehen, die abgearbeitet werden [Harinarayan et al.<br />
(1996) S. 4].<br />
Dabei wird folgendes lineares Kostenmodell entwickelt:<br />
T=m*S+c<br />
Dabei ist T die Laufzeit der Anfrage mit der Größe S. Und c gibt die Fixkosten (fixe<br />
Zeit) wieder. In dem empirischen Modell ermittelten Harinarayan et al. beispielhaft die<br />
Fixkosten mit 2.07 Sekunden durch experimentelles Austesten in einer Datenbank. m ist<br />
das Verhältnis der Abfragezeit zu der Größe S der Abfrage nach Abzug der Fixkosten.<br />
In der Tabelle werden die Ergebnisse von Harinarayan et al. präsentiert:<br />
- 110 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Source Size Time (sec.) Ratio<br />
From cell itself 1 2,07 not applicable<br />
From view (supplier) 10000 2,38 0,000031<br />
From view (part, supplier) 800000 20,77 0,000023<br />
From view (part, supplier, customer) 6000000 226,23 0,000037<br />
Tabelle 9: Entwicklung der Query Response Time im Verhältnis zur Size<br />
[Quelle: Harinarayan et al. (1996) S. 11]<br />
Es gibt eine Reihe unterschiedlicher heuristischer Ansätze, wie die Kosten für eine<br />
Anfrage geschätzt werden können. Zur Schätzung der Eingangsdatenmenge ist aber<br />
zumeist auch die Menge der selektieren Tupel in der Gesamtmenge von Belang. Kessler<br />
(1997) teilt dabei die Schätzverfahren, welche die Anzahl der Tupel einer Relation, die<br />
ein bestimmtes Selektionsprädikat erfüllen, schätzen, in fünf prinzipielle<br />
Vorgehensweisen ein [vgl. Kessler (1997) S. 182ff]:<br />
• Es wird eine Gleichverteilung der Attributwerte angenommen. Mittels<br />
Statistikformeln wird die Zahl der Tupel geschätzt. Dabei wird eine<br />
Gleichverteilung der Attributwerte angenommen und für jede Relation und jedes<br />
Attribut die Anzahl der Tupel in der Relation, die Anzahl verschiedener<br />
Attributwerte, der kleinste Attributwert, der größte Attributwert und die<br />
Intervallbreite (entspricht größter minus kleinster Attributwert) ermittelt und in<br />
einer Min-Max-Statistik gespeichert. Ausgehend von diesen Werten wird die<br />
Selektivität der einzelnen Prädikattypen geschätzt und durch Multiplikation von<br />
der Anzahl der Tupel in der Relation und Selektivität die erwartete Anzahl der<br />
qualitativen Tupel geschätzt.<br />
• Es wird eine Ungleichverteilung, die durch eine geeignete<br />
Wahrscheinlichkeitsverteilung approximiert werden kann, angenommen. Die<br />
Zahl der Tupel wird wieder durch Anwendung von Formeln der Statistik<br />
geschätzt. (siehe letzter Absatz)<br />
• Die Ungleichverteilung der Attributwerte wird durch ein Histogramm<br />
beschrieben. Aus diesem wird die Zahl der Tupel berechnet. Grundsätzlich<br />
lassen sich vollständige und komprimierte Histogramme unterscheiden. In einem<br />
vollständigen Histogramm wird von jedem einzelnen Attributwert erfasst, wie<br />
oft er auftritt. Der Vorteil dieser Histogramme ist ihre Exaktheit. Der Nachteil<br />
ist die große Datenmenge, welche zu speichern ist. In einem komprimierten<br />
- 111 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Histogramm wird die Datenmenge eingeschränkt, indem das Gesamtintervall in<br />
n halboffene, nicht notwendigerweise gleich große Teilintervalle aufgeteilt wird.<br />
Für jedes Teilintervall i wird ein Eintrag erzeugt. Dieser enthält den größten<br />
Attributswert, die Anzahl der Tupel und die Anzahl verschiedener Attributwerte<br />
im Intervall. Zusätzlich wird ein Eintrag (Teilintervall 0) mit der unteren Grenze<br />
des Intervall 1 angelegt.<br />
• Es wird keine Annahme über die Attributwertverteilung gemacht. Die Zahl der<br />
qualifizierten Tupel wird durch Multiplikation der Gesamtzahl der Tupel mit<br />
einer für die einzelnen Prädikatstypen heuristisch festgelegten Selektivität<br />
ermittelt.<br />
• Zum Zeitpunkt, zu dem eine Anfrage optimiert wird, wird auf die Relation<br />
zugegriffen und aus ihr eine Stichprobe, bestehend aus einer bestimmten Anzahl<br />
Tupel, entnommen. Ausgehend von dieser Stichprobe wird hochgerechnet, wie<br />
viele Tupel sich insgesamt qualifizieren werden.<br />
Die unterschiedlichen Ansätze zielen alle auf eine Kostenschätzung durch die<br />
Schätzung der Seitenzugriffe ab. Da in unserem Datawarehouse für das Materialisieren<br />
der Würfel typischerweise so genannte GROUP BY Abfragen durchgeführt werden,<br />
werden alle Tupel, bzw. Blöcke des Tables gelesen. Somit ergibt sich die Anzahl der<br />
Readoperationen RS für das Scannen des Table aus<br />
RS = Anzahl der Tupel im Table count(r)/ Anzahl der Tupel pro ReadBlock<br />
Ein ähnlicher Ansatz findet sich auch bei Kessler (1997).<br />
Zusätzlich werden jedoch noch Read Operationen für die GROUP BY Operation<br />
benötigt. Dabei kann die Schätzfunktion von Dunemann (2002) verwendet werden.<br />
⎛ count(<br />
r)<br />
⎞<br />
count ( γ L ( r))<br />
≈ min⎜<br />
, ∏ ( distinct(<br />
r,<br />
a)<br />
)⎟<br />
⎝ 2 a∈L<br />
⎠<br />
[vgl. Dunemann (2002) S. 74]<br />
Damit sagt Dunemann, dass die Anzahl der Tupel einer GROUP BY Operation gleich<br />
dem Produkt der einmaligen Einträge der Tabellen sind oder wenn diese nicht bekannt<br />
mit der halben Tupelanzahl geschätzt wird. Diese sind in meiner Software durch den<br />
Benutzer einzugeben und in der Regel bekannt. So weiß der Benutzer, welcher eine<br />
- 112 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
GROUP BY Abfrage über Kundengruppe und Mitarbeiter haben möchte, sowohl die<br />
Anzahl der Kundengruppen als auch die Anzahl der Mitarbeiter. Für im Zeitablauf<br />
ändernde Voraussetzungen beim Aufbau des Warehouse ist eine Anpassung der<br />
Struktur durchzuführen. Denn eine Zunahme der Anzahl der Mitarbeiter führt zu einer<br />
Veränderung der Struktur und kann eine veränderte Auswahl der materialisierten<br />
Würfel bedeuten.<br />
Des weiteren muss die Sortierung der GROUP BY Ergebnisse beachtet werden. Dabei<br />
hängt nach Dunemann die Zeit für die Sortierung sehr stark von der Verfügbarkeit des<br />
Hauptspeichers ab. Kann dieser alle zu sortierenden Tupel aufnehmen, erfolgt die<br />
Sortierung nach dem Einlesen ohne weitere Plattenzugriffe. Die Kosten sind also<br />
identisch mit der eines Scans. Ist der Hauptspeicher nicht ausreichend, muss ein anderes<br />
Verfahren zum Einsatz kommen, welches auf der Festplatte sortiert. So kann das<br />
Verfahren Merge-Sort, welches bei großen Datenbeständen Einsatz findet, mit<br />
folgenden geschätzten Kosten verwendet werden:<br />
cos t E ( MergeSort(<br />
rclustered<br />
)) = 3*<br />
blocks(<br />
rclustered<br />
)<br />
[vgl. Dunemann (2002) S. 60]<br />
Dabei ergeben sich die Kosten einer Sortierung durch die Multiplikation der Anzahl der<br />
Clustered Blocks mit drei. Wenn man diese Kostenschätzung auf die GROUP BY<br />
Anfrage anwendet, wäre dies:<br />
( FactScan ( cube)<br />
) + 2*<br />
cost<br />
( FactScan ( cube)<br />
)<br />
cos t E ( MergeSortL<br />
( cube))<br />
= cost<br />
E<br />
ds(<br />
cube)<br />
E<br />
local<br />
Damit wären die Kosten für eine GROUP BY Abfrage einmal das Lesen des gesamten<br />
Abfragewürfels und zwei mal die IO Kosten (Schreiben und Lesen) für den neuen<br />
materialisierten Würfel. [vgl. Dunemann (2002) S. 165]<br />
Die komplettesten Ansätze, speziell auf die Bewertung der CPU Kosten in GROUP BY<br />
Abfragen von Datawarehouse Systemen zugeschnitten, finden sich bei Jianzhong<br />
(1999). Sie definieren R(D1, D2, …, Dn; M) als eine multidimensionales Dataset. Die<br />
Dimensionsreihenfolge von R ist dabei D i , Di<br />
,..., D<br />
2 in<br />
und 1 i j<br />
- 113 -<br />
D entspricht dem i-ten<br />
Element in der j-ten Dimension. Die Aggregation von R(D1, D2, …, Dn; M) ergibt eine<br />
Group-by Dimensionsmenge { A , A2<br />
,..., Ak<br />
} { D1,<br />
D2,...,<br />
Dn}<br />
Aggregationsfunktion F. Damit ist ( A A ,..., A ; F(<br />
M ) )<br />
1 ⊆ und eine<br />
S k das Ergebnisset, wo die<br />
1,<br />
2
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Kosten F(M) durch die Kennzahlen von R in die Aggregationsfunktion F eingesetzt und<br />
errechnet werden.<br />
Jianzhong et al. (1999) beschreiben mehrere Aggregationsalgorithmen. Allerdings<br />
betreffen diese Algorithmen komprimierte Daten, sodass einige Dekomprimierungsbzw.<br />
Komprimierungsschritte in den Kostenfunktionen angeführt werden, welche nicht<br />
unbedingt notwendig sind. Ich möchte den von ihnen vorgestellten G-Aggregationsalgorithmus,<br />
den M-Algorithmus und den Prefix-Algorithmus hier erwähnen. G steht<br />
dabei für „genereller“ Algorithmus, da er in allen Situationen eingesetzt werden kann.<br />
Dabei wird die Transpositionsphase und die Aggregationsphase unterschieden. Der M-<br />
Aggregationsalgorithmus beschreibt die G-Aggregation in dem Fall, wenn das<br />
Aggregationsergebnis in den Speicher passt. Der Präfix-Algorithmus hat den Vorteil<br />
durch die Situation, dass die Group by Dimensionen ein Prefix der Dimensionsordnung<br />
D D , K , D des Datasets ( ) M D D D R n ; , , K ist. Dadurch kann die Aggregation in<br />
1, 2<br />
n<br />
, 1 2<br />
einem Schritt im Hauptspeicher durchgeführt werden.<br />
Abbildung 45: Beispielhafte Arbeitsabfolge im G-Algorithmus [Quelle: Jianzhong (1999) S. 654]<br />
Die Kostenschätzungen der Algorithmen für die CPU Kosten lauten wie folgt:<br />
⎡ N ⎤ ⎛ ⎡<br />
= 2Nn<br />
+<br />
⎢<br />
B log B + ⎜ N 2N<br />
log<br />
B ⎥ ⎜<br />
+ ⎢<br />
⎣ ⎦ ⎝ ⎣<br />
- 114 -<br />
⎡ N ⎤⎤<br />
⎞<br />
⎢<br />
⎟ log<br />
BW ⎥⎥<br />
⎣ ⎦<br />
⎟<br />
⎦⎠<br />
CPU G 2<br />
r w<br />
2<br />
CPU = 2 Nn + Nh + N<br />
M<br />
CPU = N(<br />
2n<br />
+ 1)<br />
+ N<br />
Pr efix<br />
N … Anzahl der Tupel im Abfragetable<br />
n … Anzahl der Dimensionen<br />
r<br />
r<br />
W
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
B … Anzahl der Tupel pro Block<br />
N r … Anzahl der Tupel in der Ergebnistabelle<br />
W … Anzahl der benötigten Buffer<br />
h … Anzahl der Berechnungen der Hashing Berechnung<br />
[vgl. Jianzhong (1999) S. 653ff]<br />
Dunemann (2002), welcher in seinen Betrachtungen die CPU Kosten für die Abfragen<br />
ignoriert, hat einige bemerkenswerte praktische Untersuchungen über den<br />
Zusammenhang von Größe der BFT (Anzahl der Tupel in der BFT - count facts ) und der<br />
Laufzeit (Kosten) einer GROUP BY Abfrage sowie über den Zusammenhang von der<br />
Größe der Ergebnis-GROUP BY Tabelle (Anzahl der Tupel in den materialisierten<br />
Sichten - count cells ) durchgeführt. Dabei errechnet er die Anzahl der count cells aus einer<br />
Zeitdimension einem Quartal (13 Wochen) sowie 27 Kostenarten, 20<br />
Organisationseinheiten und einer Kennzahl folgende Formel:<br />
count cells<br />
= M * Zeit * Kostenart * Organisation<br />
=(1+1)*(13+1)*(27+1)*(20+1)<br />
= 16464<br />
Dabei wird pro Dimension ein Element für undefinierte Werte berücksichtigt. Der<br />
Zusammenhang der Kosten (beziehungsweise der Laufzeit) mit der Anzahl der<br />
count facts ergibt sich nach den Ergebnissen der Tests wie folgt:<br />
count 1000 2000 3000 4000 5000 6000 7000<br />
facts<br />
Laufzeit 3,707 6,360 8,686 10,790 13,486 16,484 22,063<br />
Somit ergibt sich ein Korrelationskoeffizient von ρ =0,986. Je dichter dieser Wert bei 1<br />
liegt, desto eindeutiger ist die Korrelation. Ähnliche Tests wurden mit größeren<br />
Tabellen durchgeführt und brachten ähnliche Ergebnisse.<br />
Zur Untersuchung der Korrelation zwischen count cells und der Laufzeit werden durch<br />
Dunemann (2002) folgende Ergebnisse präsentiert:<br />
count 16464 31572 47040 62328 77616 92904<br />
cells<br />
Laufzeit 13,486 38,510 67,868 91,401 118,867 135,671<br />
- 115 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Das Ergebnis der linearen Reggressionsanalyse ist ρ =0,998. Damit besteht ein starker<br />
Zusammenhang für Kostenschätzungen. Die Auswertung für die größeren Datenwürfel<br />
bestätigte das Ergebnis, welches für die kleinen Datenwürfel ermittelt worden ist.<br />
Allerdings konnte eine geringere Korrelation festgestellt werden. Deshalb trifft<br />
Dunemann (2002) die Schlussfolgerung, das bei größeren Datenwürfeln der Einfluß der<br />
count cells im Verhältnis zum Einfluss der count facts geringer ist.<br />
[vgl. Dunemann (2002) S.235ff]<br />
Grundsätzlich kann festgestellt werden, dass über die Kostenschätzungen für Abfragen<br />
in der Literatur Uneinigkeit besteht. Dies ist vermutlich darauf zurückzuführen, dass die<br />
Kosten, bzw. die Zeit für eine Abfrage sehr stark von den aktuellen Eigenschaften der<br />
Datenbank abhängen. Trotzdem sind einige Ansätze zu finden, welche ich in einer<br />
weiter unten angeführten Kostenfunktion für meine Berechnungen verwende möchte.<br />
7.6 DIE HEURISTIKEN<br />
7.6.1 EINTEILUNG DER KOSTEN<br />
Um eine Auswahl der zu materialisierenden Würfel treffen zu können, ist es notwendig,<br />
die Kosten für diese Würfel zu berechnen. Dazu habe ich Kostenschätzfunktionen,<br />
welche sehr realitätsnah aber auch nicht zu komplex sein sollen, -da sie die<br />
Grundparameter für die Software darstellen, welche im Lehrbetrieb eingesetzt werden<br />
soll- entwickelt. Diese Kostenschätzfunktionen basieren auf den Ausführungen in<br />
Kapitel 7.5 und haben grundsätzlich auf das Ergebnis der Bewertung der Heuristik<br />
keinen Einfluss. Es ist auch möglich eine Bewertung der Heuristik mit zufällig<br />
hinterlegten Kosten durchzuführen (siehe dazu Kapitel 7.6.5). Ich möchte die<br />
Funktionen aber trotzdem sehr praxisnah ausformulieren, damit die Software nicht nur<br />
für die Lehre und Forschung einsetzbar ist -und nur Aufschluss über die Bewertung der<br />
Heuristiken gibt - sondern auch für die Entwicklung eines richtigen Warehouse<br />
eingesetzt werden kann. Somit liefert die Software realitätsnahe Ergebnisse. Allerdings<br />
ist natürlich diese Kostenfunktion für den praktischen Einsatz nicht ausreichend.<br />
Deshalb erscheint es für Datenbankentwickler sinnvoll ihre geheimen Query Optimizer<br />
Funktionen mit meiner Heuristik zu kombinieren und ein Endanwenderprodukt zu<br />
programmieren. Die Suche nach einer Kostenfunktion ist aber nicht der Kern meiner<br />
Forschung und einer Verbesserung der Kostenfunktion in nachfolgender<br />
Forschungstätigkeit steht jedenfalls nichts im Wege.<br />
Nach meinem Ansatz unterscheide ich zwischen Kosten für die Materialisierung eines<br />
Würfels aus einem anderen Würfel oder dem BFT und den Kosten für das Abfragen<br />
eines Würfels. Diese Unterscheidung ist deshalb essentiell, da die Kosten für die<br />
- 116 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Materialisierung während des Aufbaues des Warehouse auftreten, die Kosten für die<br />
Abfragen jedoch beim Benutzen des Warehouse durch den User (siehe dazu Kapitel<br />
7.3). Es gibt für mich ein Zeitlimit und Speicherplatzlimit auf der Materialisierungsebene.<br />
Zusätzlich will ich aber den Ansatz von Prosser durch ein Zeitlimit für Abfragen<br />
auf der Userebene erweitern, da auch die Zeitanforderungen der Benutzer hinsichtlich<br />
Wartezeit auf Ergebnisse einbezogen werden sollten. Dieses Zeitlimit ist aber nicht<br />
zwingend. Das heißt, es kann durchaus die eine oder andere Abfrage länger als die<br />
durchschnittliche gewünschte Wartezeit der User sein. Allerdings ist die<br />
durchschnittliche Abfragedauer aller Abfragen limitiert. Dazu werden die Würfel,<br />
welche für die Benutzer interessant sind, entsprechend der Wartezeit und der<br />
Abfragehäufigkeit klassifiziert.<br />
Somit ergibt sich folgende Kostenfunktion:<br />
Gesamtkost en = Kosten der Abfragephase<br />
+<br />
- 117 -<br />
Kosten der Materialisierungsphase<br />
7.6.2 KOSTENSCHÄTZFUNKTION DER ABFRAGEPHASE<br />
Ich betrachte hierbei die Kosten für die Abfrage eines Würfels w welcher ein Derivativ<br />
des Würfels v ist. Dieser Würfel w muss also durch eine Abfrage des Würfels v<br />
errechnet werden. Analog ist eine Abfrage eines Würfels w aus dem Base Fact Table zu<br />
sehen. Die Abfrage eines materialisierten Würfels w ist nach meiner Definition 0, da er<br />
nicht errechnet werden muss, sondern bereits aggregiert vorliegt.<br />
7.6.2.1 BEGRIFFSDEFINITIONEN<br />
AnztupelQUERY … Anzahl der Tupel in der abzufragenden Tabelle, bzw. des Joins<br />
Anztupel GROUPBY … Anzahl der Tupel, welche in dem materialisierten View gespeichert<br />
werden<br />
AvTime IO … Durchschnittliche Zeit für die IO Operation eines Tupels<br />
AvTime CPU … Durchschnittliche CPU Zeit für einen Sortierungsschritt in der Group By<br />
Abfrage<br />
Avtime MAX … durchschnittlich verfügbare Zeit pro Abfrage (maximale<br />
durchschnittliche Wartezeit des Benutzers)
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.6.2.2 WERTEBEREICHE UND BEDINGUNGEN<br />
• Wertebereich von Anztupel QUERY , AvTime CPU , Anztupel GROUPBY , AvTime IO<br />
und Avtime MAX : 0 ≤ x ≤ ∞<br />
7.6.2.3 FUNKTION<br />
⎧ AvTimeIO<br />
*<br />
+<br />
Kosten = ⎨<br />
⎩<br />
Avtime<br />
( AnzTupelQUERY<br />
2 * ( AnzTupelGROUPBY<br />
) ) ⎫<br />
+<br />
- 118 -<br />
MAX<br />
[ log AnzTupel ]<br />
⎧ AnzTupel GROUPBY * 2<br />
GROUPBY * AvTime<br />
⎨<br />
⎩<br />
AvtimeMAX<br />
7.6.2.4 BESCHREIBUNG DER KOSTENSCHÄTZFUNKTION<br />
Die Abfragekosten werden mit dem Ausnutzungsgrad der Abfragezeit bewertet. Wenn<br />
also die Benutzer eine Abfragezeit mit durchschnittlich 10 Sekunden benötigen, gibt<br />
eine Aussage der Abfragekosten von 0,8 eine durchschnittliche Abfragedauer von 8<br />
Sekunden an. Dabei werden die Anzahl der Tupel, zuerst beim Table Scan in den<br />
Hauptspeicher gelesen und dann wird der CPU Zeit beim Sortieren und Aggregieren<br />
durch eine Schätzformel berechnet und mit der durchschnittlichen IO Zeit pro Operation<br />
multipliziert. Diese Schätzformel ist stark vereinfacht. Für den Zweck im Lehrbetrieb<br />
gut Ergebnisse zu erhalten aber jedenfalls ausreichend.<br />
7.6.3 KOSTENSCHÄTZFUNKTIONEN DER MATERIALISIERUNGSPHASE<br />
Die Kosten der Materialisierung versuche ich, in Anteilen der durch die<br />
Materialisierung verbrauchten Ressourcen an den Gesamtressourcen, zu berechnen. Je<br />
geringer der Ressourcenverbrauch der Materialisierung, desto kostengünstiger ist die<br />
Materialisierung. Dieser Ansatz ermöglicht die Kosten nicht in absoluten Zahlen, wie<br />
etwa in einer Währung, darzustellen zu müssen. Die realen Kosten einer Abfrage sind<br />
von unzähligen Parametern, wie Datenbankhersteller, Datenbank, Indizes,<br />
Hardewareparametern, Betriebssystemen, usw. abhängig und ändern sich auch im<br />
Zeitablauf.<br />
7.6.3.1 BEGRIFFSDEFINITIONEN<br />
AnztupelQUERY … Anzahl der Tupel in der abzufragenden Tabelle, bzw. des Joins<br />
CPU<br />
⎫<br />
⎬<br />
⎭<br />
⎬<br />
⎭
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Anztupel GROUPBY … Anzahl der Tupel, welche in dem materialisierten View gespeichert<br />
werden<br />
AvTime IO … Durchschnittliche Zeit für die IO Operation eines Tupels<br />
AvTime CPU … Durchschnittliche CPU Zeit für einen Sortierungsschritt in der Group By<br />
Abfrage<br />
AvTime STORE … Durchschnittliche Zeit zum Speichern eines Tupels in dem<br />
materialisierten View<br />
time MAX … Maximal verfügbare Zeit<br />
space MAX … Maximal verfügbarer Speicherplatz<br />
AvSize STORE … Durchschnittlicher Speicherplatz beim Speichern eines Tupels im<br />
materialisierten View<br />
weight TIME … Gewichtung der Zeit<br />
weight SPACE … Gewichtung des Speicherplatzes<br />
7.6.3.2 WERTEBEREICHE UND BEDINGUNGEN<br />
• Wertebereich von Anztupel QUERY , Anztupel STORE , AvTime IO , Anztupel QUERY ,<br />
AvTime STORE , AvSize STORE und AvTime CPU : 0 ≤ x ≤ ∞<br />
• Wertebereich von time MAX , space MAX : 0 < x ≤ ∞<br />
• Wertebereich von weight TIME , weight SPACE : 0 ≤ x ≤ 1<br />
• Es gilt die Nebenbedingung: weight TIME + weight SPACE =1<br />
7.6.3.3 FUNKTION<br />
( AnzTupel 2*<br />
( AnzTupel ) )<br />
⎧ AvTimeIO<br />
*<br />
QUERY +<br />
GROUPBY ⎫<br />
Kosten ⎨<br />
⎬*<br />
weight<br />
⎩<br />
AvtimeMAX<br />
⎭<br />
⎧<br />
⎨<br />
⎩<br />
= TIME<br />
[ AnzTupel log AnzTupel ]<br />
GROUPBY * 2<br />
⎧<br />
AvSize<br />
⎨<br />
⎩<br />
STORE<br />
Avtime<br />
MAX<br />
* AnzTupel<br />
space<br />
MAX<br />
GROUPBY<br />
GROUPBY<br />
- 119 -<br />
* AvTime<br />
⎫<br />
⎬*<br />
weight<br />
⎭<br />
CPU<br />
SPACE<br />
⎫<br />
⎬*<br />
weight<br />
⎭<br />
TIME<br />
+<br />
+
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Die Kosten werden durch den Ressourcenverbrauch von Zeit und Speicherplatz<br />
bewertet. Durch die Gewichtungsfaktoren weight SPACE für den Gewichtungsfaktor des<br />
Speicherplatzes und weight TIME für den Gewichtungsfaktor der Zeit kann der Benutzer<br />
die Kosten für Zeit und Speicherplatz gewichten. Der Speicherplatzverbrauch wird in<br />
Anteilen des verbrauchten Speicherplatzes ( AvSize STORE * Anztupel STORE ) am<br />
Gesamtspeicherplatz space MAX ausgedrückt.<br />
Auf Seiten der Zeitdimension wird der Zeitverbrauch in Anteilen am<br />
Gesamtzeitverbrauch für die Read/Write Operationen und für die CPU Operationen<br />
berechnet. Dazu wird die Durchschnittliche Zeit für IO Operationen pro Tupel mit der<br />
Anzahl der zu lesenden und schreibenden Tupel multipliziert. Diese Anzahl der Tupel<br />
berechnet sich nach Dunemann (2002) (siehe auch Kapitel 7.5) für eine GROUP BY<br />
Abfrage einmal durch das Lesen des gesamten Abfragewürfels und zwei mal die IO<br />
Kosten (Schreiben und Lesen) für den neuen materialisierten Würfel. Der Anteil des<br />
Zeitverbrauches durch das Sortieren der Group by Tupels wird durch die Anzahl der<br />
Sortierungsschritte multipliziert mit der durchschnittlichen CPU Zeit pro<br />
Sortierungsschritt geschätzt und anschließend gewichtet.<br />
7.6.3.4 BESCHREIBUNG DER KOSTENSCHÄTZFUNKTION<br />
Die Materialisierungskosten werden in Anteilen am Ressourcenverbrauch bewertet und<br />
anschließend noch nach ihrer Wichtigkeit bewertet. So kann der Benutzer stufenlos<br />
entscheiden, ob er das Speicherplatzlimit oder das Zeitlimit höher bewerten will. Die<br />
Berechnung der Zeit ergibt sich durch Addieren der Zeit für das Abfragen, für die<br />
Group by Abfrage des Würfels und der Zeit für das Speichern des neuen Würfels in der<br />
Datenbank. Der Speicherplatz wird einfach durch Multiplikation der durchschnittlichen<br />
Größe eines Tupels mit der Anzahl der zu speichernden Tupel ermittelt.<br />
7.6.4 GESAMTKOSTEN<br />
Die Gesamtkosten ergeben sich durch Addieren und Gewichten der Abfragekosten und<br />
der Materialisierungskosten.<br />
7.6.4.1 BEGRIFFSDEFINITIONEN<br />
KostenQUERY … Kosten der Abfrage<br />
n<br />
Kosten … Kosten der Materaliserung des zu materialisierenden Würfels m<br />
MATERALISIERENm<br />
weight QUERY … Gewichtung der Abfragekosten<br />
- 120 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
weight MATERALISIEREN<br />
…Gewichtung der Materalisierungskosten<br />
m … Zähler aller zu materialisierenden Würfel<br />
Anz n … Häufigkeit der Abfrage n durch den Benutzer pro Zeitintervall<br />
n … Zähler aller abzufragenden Würfel<br />
7.6.4.2 WERTEBEREICHE UND BEDINGUNGEN<br />
• Wertebereich von<br />
Kosten , Kosten MATERALISIEREN<br />
, n , m, Anz m<br />
n : 0 ≤ x ≤ ∞<br />
QUERY n<br />
• Wertebereich von weight QUERY , weight MATERALISIEREN<br />
: 0 ≤ x ≤ 1<br />
• Es gilt die Nebenbedingung: weight QUERY + weight MATERALISIEREN<br />
=1<br />
7.6.4.3 FUNKTION<br />
n<br />
[ KostenQUERY<br />
Anzn<br />
] * weightQUERY<br />
+ KostenMATERALISIEREN<br />
weight MATERALISIEREN<br />
Kosten = ∑<br />
* *<br />
n ∑<br />
7.6.5 ZUFÄLLIGE KOSTEN<br />
Um eine wissenschaftlich fundierte Aussage über die Wertigkeit und Funktionalität der<br />
Heuristik zu treffen, will ich ein Austesten der Heuristik mit zufällig gewählten Kosten<br />
durchführen. Dies soll auch die Unabhängigkeit der Heuristik von den<br />
Kostenschätzfunktionen unterstreichen. Dabei können die Kosten grundsätzlich völlig<br />
unstrukturiert zufällig gewählt sein und die Heuristik muss die gleichen Ergebnisse<br />
liefern als die deterministische Lösung. Allerdings will ich, um die Kosten an die realen<br />
Verhältnisse anzupassen, einige Nebenbedingungen beachten.<br />
m<br />
- 121 -<br />
m
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 46: Schematische Aufstellung der Würfel und Kostenfunktionen<br />
In Abbildung 46 gebe ich eine Aufstellung eines exemplarischen Kostenbaumes. Ich<br />
unterscheide Würfel der ersten Ebene V, welche nur aus dem BFT materialisiert werden<br />
können, und Würfel der zweiten Ebene W, welche aus dem BFT oder aus einem Würfel<br />
der Ebene V materialisiert werden können. Diese Aufstellung kann natürlich um<br />
beliebige Ebenen erweitert werden. Dabei gehe ich von folgenden Grundannahmen aus:<br />
• Eine Kostenfunktion f() symbolisiert Kosten für die Materialisierung oder die<br />
Abfrage eines Würfels, in welchem eine Kante endet aus dem Würfel oder dem<br />
BFT, aus welchem die Kante entspringt.<br />
• Die Kosten für die Materialisierung oder die Abfrage eines Würfels der Ebene V<br />
ist immer größer als die Kosten für die Materialisierung oder die Abfrage eines<br />
Würfels der Ebene W direkt aus dem BFT, wenn die Anzahl der Group by<br />
Dimensionen von V größer ist als die Anzahl der GROUP BY Dimensionen von<br />
W. Das ergibt sich daraus, dass die CPU Kosten für eine Berechnung höher sind<br />
und die Größe der Ergebnistabelle V wesentlich mehr Tupels enthält. Haben V<br />
und W gleich viele GROUP BY Dimensionen hat V immer mehr Tupels als W in<br />
der Ergebnistabelle. Deshalb ist auch bei gleicher Anzahl der GROUP BY<br />
Dimensionen f(BFT,W) immer teurer als f(BFT,V).<br />
Forderung: ( f ( BFT,<br />
Vx)<br />
f f ( BFT,<br />
Wy)<br />
).<br />
• Die Kosten für die Materialisierung oder die Abfrage eines Würfels W aus der<br />
Vorgängerebene V ist immer kleiner oder gleich den Kosten für die<br />
- 122 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Materialisierung des Würfels W aus dem BFT. Diese Forderung ergibt sich<br />
daraus, dass ein Aggregat immer weniger Einträge besitzt als der BFT und damit<br />
die Berechnungskosten (Tablescan und CPU Aggregations- und<br />
Sortierungskosten) kleiner sind. Forderung:( f ( Vx,<br />
Wx)<br />
p f ( BFT,<br />
Wx)<br />
)<br />
• Die Kosten für die Materialisierung oder die Abfrage eines Würfels der höheren<br />
Ebene W aus der Vorgängerebene V ist immer kleiner als die Kosten für die<br />
Materialisierung oder die Abfrage eines Würfels der niederen Ebene V aus deren<br />
Vorgängerebene U, wenn es sich um die gleiche Aggregationsdimension<br />
handelt. Das heißt eine Aggregation vom BFT → Kundengruppe<br />
ist immer<br />
teurer als eine Aggregation von Kundengruppe → Kundentotal<br />
. Diese<br />
Forderung ergibt sich daraus, dass z.B. die Abfrage einer Kundendatei mit<br />
50000 Einträgen immer länger dauert als eine Abfrage eines materialisierten<br />
Würfels Kundengruppe mit 5 Einträgen bei 5 Kundengruppen. Da aber eine<br />
nachfolgende Hierarchiestufe nie mehr Einträge haben kann als eine<br />
vorhergehende, ergibt sich oben angeführte Forderung.<br />
Forderung: ( f ( Vx,<br />
Wy)<br />
p f ( Uz,<br />
Vx)<br />
)<br />
• Die Kosten für das Materialisieren eines Würfels W1 aus dem Würfel V1 sind<br />
immer höher als die Kosten für das Abfragen des Würfels W1 aus dem<br />
materialisierten Würfel V. Diese Forderung ist schlüssig, da das Materialisieren<br />
auch ein Abfragen beinhaltet. Allerdings sind noch zusätzlich Operationen wie<br />
etwa Speichern, Sortieren, etc. notwendig, welche die höheren Kosten bedingen.<br />
Forderung: Abfragekosten
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Kosten der Erstellung von einem Würfel zum anderen oder direkt aus dem BFT, der<br />
Anzahl der Tables über die ein Join gemacht werden muss, der Anzahl der<br />
Dateneinträge, welche durchsucht werden müssen, dem Grad der weiteren Aggregation<br />
und der Index Struktur, beeinflusst. Ein Query Optimizer kann benutzt werden, um<br />
diese Information zu liefern, welche benutzt werden kann um die Kosten zwischen den<br />
Würfeln δ ( v,<br />
w)<br />
zu schätzen. Die Kosten für die Materialisierung von v aus dem BFT<br />
wären dann C M ( v)<br />
= δ ( BFT,<br />
v)<br />
. Analog sind die Kosten für das Materialisieren von w<br />
aus v aus einer Abfrage ( w)<br />
= δ ( v,<br />
w)<br />
. Die Kosten für weitere Abfragen und<br />
C Q<br />
Berechnungen basierend auf w werden nicht betrachtet, da diese ohnehin anfallen. Als<br />
Berechnungsgrundlage haben wir eine Menge von interessanten Würfeln (required<br />
cubes) und die relative Wichtigkeit f(w) für jeden Würfel. Der marginale Nettoeffekt<br />
E(.), wenn nur v als einziger Würfel im APA betrachtet wird, ist die Differenz zwischen<br />
den Kostenverminderung, durch die Tatsache das alle Derivate w ∈ A(v)<br />
von v direkt<br />
aus v anstatt vom BFT berechnet werden können, im Vergleich zu den Kosten für die<br />
Materialisierung von v. Wird v vom BFT als der erste Cube materialisiert gilt:<br />
∑<br />
E ( M = {}, v)<br />
= [ f ( w)<br />
* ( δ ( BFT,<br />
w)<br />
− δ ( v,<br />
w))]<br />
− δ ( BFT,<br />
v)<br />
w ≠ v,<br />
w ∈ A(<br />
v)<br />
w<br />
Dabei ist es nicht notwendig w ∈ A(v)<br />
auf die interessanten Würfel zu beschränken, da<br />
die uninteressanten Würfel die relative Wichtigkeit von f(w) = 0 haben. Die Kosten für<br />
die Materialisierung der Menge M = {v} beträgt somit<br />
C(<br />
M ) = δ ( BFT,<br />
v)<br />
+ ∑ f ( w)<br />
* δ ( BFT,<br />
w)<br />
+ ∑ f ( w)<br />
* δ ( v,<br />
w)<br />
w∉<br />
A(<br />
v)<br />
w∈A(<br />
v)<br />
Deshalb kann das Optimierungsproblem definiert werden als:<br />
min<br />
M<br />
→ C(<br />
M ), s * t * space(<br />
M ) ≤ space<br />
Für dieses Problem definiert Prosser die Heuristik wie folgt:<br />
- 124 -<br />
max<br />
, s * t * time(<br />
M ) ≤ time<br />
Berechne E(BFT,v) für jeden Würfel im APA und definiere v mit dem höchsten<br />
E(BFT,v) als ersten Würfel welcher M zugesetzt wird. Somit ist M1={v}<br />
Führe die folgende Prozedur durch:<br />
Spaceortime_limit_reached ← false<br />
/* k is used as a counter for the iterations */<br />
k=1<br />
do until spaceortime_limit_reached=true<br />
w ≠ v<br />
max
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
// define the set of all cubes which can be derived from any materialized cube<br />
at stage k<br />
define A(<br />
M k ) U<br />
x∈M<br />
k<br />
= A(<br />
x)<br />
/* the net effect of each single cube which has not been materialized yet is<br />
computed*/<br />
do for all k M w ∈<br />
end do<br />
/* the u ∈ A(w)<br />
may already be in the derivative set of materialized<br />
cubes */<br />
^<br />
define U k ( w)<br />
= { u / u ∈ A(<br />
w)^<br />
u ∈ A(<br />
M )}<br />
define U k ( w)<br />
= { u / u ∈ A(<br />
w)^<br />
u ∉ A(<br />
M k )}<br />
/* is cube w itself a derivative of another cube which has already been<br />
materialized?*/<br />
if ( k ) M A w ∉<br />
else<br />
end if<br />
/* no → w can only be built from the BFT */<br />
k<br />
= ∑<br />
u∈U<br />
[ f ( u)<br />
* ( δ ( BFT,<br />
u)<br />
− ( w,<br />
u ]<br />
E ( M , w)<br />
δ ))<br />
∑<br />
u∈Uˆ<br />
- 125 -<br />
k<br />
[ max(<br />
0,<br />
f ( u)<br />
* ( δ ( x,<br />
u)<br />
− δ ( w,<br />
u))<br />
| ∀x<br />
∈ M / u ∈ A(<br />
x)<br />
) ] − δ ( BFT,<br />
w)<br />
/* yes → w will be built from the existing cube with the least<br />
distance measure<br />
in that case U k must be empty*/<br />
E ( M , w)<br />
[ max(<br />
0,<br />
f ( u)<br />
* ( δ ( x,<br />
u)<br />
− δ ( w,<br />
u)<br />
| ∀x<br />
∈ M / u ∈ A(<br />
x)<br />
) ]−<br />
k<br />
= ∑<br />
u∈U<br />
( δ ( x, w)<br />
| ∀x<br />
∈ M k / w ∈ A(<br />
) )<br />
min x<br />
/* now the net effect off all cubes not materialized at step k is known, the best<br />
one is chosen */<br />
+<br />
k<br />
k
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
choose → max( E(<br />
M , w)<br />
)∑M+ 1 = M ∪{<br />
w}<br />
w k<br />
k k<br />
if ( M 1)<br />
spacemaxor<br />
time(<br />
M 1)<br />
≥ timemax<br />
space k+<br />
≥ k+<br />
spaceortime_limit_reached ← true<br />
materialize k M<br />
else k ← k + 1<br />
end if<br />
end do<br />
Der Algorithmus startet mit M 1 = { v}<br />
. Danach werden so lange neue Würfel<br />
materialisiert bis entweder das Zeitlimit oder das Speicherlimit erreicht ist. In jedem<br />
Durchlauf wird zuerst k, der Nettoeffekt jedes individuellen Würfels k M w ∉ berechnet.<br />
Da wir an einem Performanceanstieg interessiert sind, welcher sich aus der Möglichkeit<br />
ergibt, die Derivative u ∈ A(w)<br />
nun direkt aus w zu erzeugen. Natürlich kann es sein,<br />
dass diese Würfel u auch ein Derivativ eines anderen Würfels k M x ∈ sind, welcher<br />
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<br />
aktuellen Zustand der Menge M k und dem Würfel w, welcher aktuell betrachtet wird,<br />
sind. Dabei werden zwei Fälle unterschieden:<br />
Wenn w kein Derivativ eines Würfels ist, welcher bereits gewählt wurde ( ( k ) M A w ∈ ),<br />
ist der Nettoeffekt E( M k , w)<br />
im Durchlauf k<br />
• für u ∈ U k (w)<br />
(also Würfel, welche sonst direkt vom BFT erzeugt<br />
werden müssten) die Kostenersparnis, welche sich durch Erzeugen von u<br />
δ − gewichtet mit f(u))<br />
aus w anstatt direkt vom BFT ( ( BFT , u)<br />
δ ( w,<br />
u)<br />
ergibt.<br />
• für alle u ∈ Uˆ<br />
k ( w)<br />
(also Würfel, welche ein Derivative eines bereits für<br />
die Materialisierung ausgewählten Würfels x sind) durch die<br />
Kostenersparnis repräsentiert, welche sich aus dem Erzeugen von u aus<br />
w anstatt aus x ergibt, wobei x bei mehreren Derivativen den Würfel mit<br />
den minimalen Materialisierungskosten repräsentiert. Dabei wird<br />
unterstellt, dass eine Kostenersparnis da ist, sonst wird diese mit 0<br />
bewertet. Daraus ergibt sich die logische Formulierung<br />
max 0,<br />
f ( u)<br />
* δ ( x,<br />
u)<br />
− δ ( w,<br />
u)<br />
| ∀x<br />
∈ M k / u ∈ A(<br />
x)<br />
. Diese wird für<br />
( ( )<br />
)<br />
- 126 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
alle u ∈ Uˆ<br />
aussummiert und wenn dieser Nettoeffekt positiv ist zum<br />
Nettoeffekt von w hinzugezogen.<br />
Da ( k ) M A w ∉ wird der Würfel direkt aus dem BFT mit den Kosten ( ) w BFT, δ<br />
materialisiert.<br />
Wenn w ein Derivative eines Würfels ist, welcher bereits im Durchlauf k für die<br />
Materialisierung ausgewählt wurde, bedeutet dies, dass keine „neuen“ Würfel gebildet<br />
werden können. Die Materialisierung vom w macht also nur dann Sinn, wenn einige<br />
Würfel bedeutend schneller materialisiert werden können als zuvor. Der Nettoeffekt der<br />
Materialisierung von w leitet sich deshalb ab durch:<br />
• Berechnen der Nettoeffekte für alle ∈ Uˆ<br />
( w)<br />
wie oben.<br />
- 127 -<br />
u k<br />
• Berechnen der Erzeugungskosten für w als die minimalen möglichen<br />
Kosten δ ( x,<br />
w)<br />
aus allen Würfeln x, aus welchen w errechnet werden<br />
kann ( w ∈ A(x)<br />
).<br />
Nachdem der Nettoeffekt aller Würfel w im APA berechnet wurde, wird jener mit dem<br />
maximalen Verbesserungsbetrag gewählt und der Menge M k+<br />
1 zugesetzt. Wenn weder<br />
das Zeitlimit oder das Speicherlimit überschritten wird, wird weitergesucht und der<br />
Durchlauf von vorne begonnen. Sonst wird die Suche abgebrochen und M k als<br />
Ergebnismenge der zu materialisierenden Würfeln festgelegt.<br />
7.6.7 HEURISTIK VON THOMAS ACHS<br />
7.6.7.1 PSEUDOCODE DER HEURISTIK<br />
{1. Vorbereitungen für die Iterationen}<br />
Erzeuge Menge R der Required Cubes<br />
Erzeuge Menge D der Derivative Cubes durch Hinzufügen aller<br />
nicht redundanten Würfel, welche mindestens 1 Derivative<br />
haben, welches wiederum in der Menge R enthalten sind.<br />
P=R ∪ D //Vereinige die Menge R und die Menge D zur Menge<br />
P der PossibleCubes für die Materialisierung.<br />
MaxSets:=20; //setzt die maximalen Sets, welche<br />
kontrolliert werden auf 20 – je höher man
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
diesen Wert setzt umso genauer wird die<br />
Heuristik.<br />
NewSetsforeachiteration:= 3; //bestimmt die zusätzlichen<br />
Sets pro Iterationsstep<br />
Setcounter:=-1; //zählt die aktuellen Wege, welche<br />
kontrolliert werden<br />
Setcount:=1;//Anzahl der Wege<br />
{Ende der Vorbereitungen für die Iterationen}<br />
{2. Iterationen der Sets}<br />
Repeat;<br />
{2.1 Vorbereiten des Startsets für die Iteration}<br />
If Setcounter=-1 then MatCube={}<br />
// Beim ersten Set ist die Menge der bereits<br />
materialisierten Würfel leer<br />
Else begin<br />
End;<br />
//Betrachte das nächste Set und errechne das<br />
verbleibende Limit<br />
MatCube=Sets[Setcounter];<br />
Berechne Limits of MatCube;<br />
{Ende 2.1. Vorbereiten des Startsets für die Iteration}<br />
{2.2. Beginn der Iteration des aktuellen Sets}<br />
While limitreached(MatCube)=false do begin<br />
- 128 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
For each Cube c ∈ P do begin<br />
//Ist der Cube c noch nicht materialisiert<br />
If bereitsmaterialisiert(c)=false then<br />
begin<br />
MinMatCosts:= MatCosts(BFT);<br />
//Die minimalen Materialisierungskosten sind<br />
die Kosten für die Materialisierung des Cubes<br />
aus dem BFT<br />
MerkeMatCube:=BFT; //MerkeMatCube enthält den<br />
Cube aus dem c erzeugt werden kann. Wenn nicht<br />
aus einem bereits materialisierten Cube<br />
abgeleitet werden kann, dann leite aus BFT ab<br />
(Standard)<br />
{2.2.1 Feststellen des Cubes aus dem der Cube c<br />
materialisiert wird: Dazu kontrolliere alle bereits<br />
materialisierten Cubes z, ob c aus z abgeleitet werden<br />
kann}<br />
For each Cube z ∈ MatCube do begin;<br />
if kannabgeleitetwerden(c,z)=true then<br />
begin<br />
//Kann der Cube aus einem bereits<br />
materialisierten Cube z erzeugt werden<br />
//Merke dir den Cube mit den minimalen<br />
Materialisierungskosten<br />
if (MatCosts(z)
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
End; //if kannabgeleitetwerden(c,z)<br />
End;//Ende von z ∈ MatCube<br />
{Ende 2.2.1 Feststellen des Cubes aus dem der Cube c<br />
materialisiert wird}<br />
{2.2.2 Festellen der Derivative und der Summe der<br />
Abfragekosten der Derivative für den Cube c}<br />
Summequery:=0; //Die Abfragekosten sind 0<br />
for each Cube x ∈ R do begin<br />
//Kontrolliere alle Required Cubes<br />
if x is derivative von c then begin<br />
//Wenn der required Cube x ein Derivative von c<br />
ist, dann beachte die Querykosten<br />
MinQueryCosts:= QueryCosts(MerkeMatCube);<br />
//Merken der minimalen Querykosten. Diese<br />
sind die Kosten für die Materialisierung<br />
aus dem Vorgänger von c.<br />
MerkeQueryCube:=MerkeMatCube;<br />
//Wenn es keinen besseren Cube y gibt wird<br />
der required cube x aus dem Vorgänger von c<br />
abgefragt, solange c noch nicht besteht.<br />
//Feststellen, ob es einen besseren Cube y<br />
gibt und speichern in MerkeQueryCubes<br />
for Each y ∈ MatCube do begin<br />
If (MinQueryCosts>QueryCosts(x,y)<br />
//Abfragekosten des required Cubes<br />
x aus dem bereits materialisierten<br />
Cube y<br />
then begin<br />
- 130 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
MerkeQueryCube:=y;//Markiere den<br />
Cube y als Abfragecube von x<br />
MinQueryCosts:=QueryCosts(y);<br />
End; //Ende von if<br />
End; //Ende von for Each y ∈ MatCube<br />
{2.2.2.1 Berechnen der Verbesserung der Abfragekosten durch<br />
das Materialisieren von c}<br />
Summequery:= Summequery+max(0,<br />
//Kosten für Abfrage von x<br />
((GetQueryCosts(MerkeQueryCube,x)-<br />
//Kosten für das Abfragen aus c<br />
GetQueryCost(c,x)))*Häufigkeit der Abfrage);<br />
{Ende 2.2.2.1 Berechnen der Verbesserung der Abfragekosten<br />
durch das Materialisieren von c}<br />
end; //ist ein Derivative<br />
end; //Ende von Each Cube x ∈ R<br />
{Ende 2.2.2 Festellen der Derivative und der Summe der<br />
Abfragekosten der Derivative für den Cube c}<br />
{2.2.3 Berechnen der Verbesserung der Gesamtkosten durch<br />
das Materialisieren von c}<br />
δK(c)=SummeQuery - GetMatCosts(MerkeMatCube);<br />
//Kostenersparnis δK(c) ist die Ersparnis bei den<br />
Abfragen (SummeQuery) minus der<br />
Materialisierungskosten für den Würfel c<br />
- 131 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
{Ende 2.2.3 Berechnen der Verbesserung der Gesamtkosten<br />
durch das Materialisieren von c}<br />
End; //Ende von If bereitsmaterialisiert(c)=false<br />
End;//von each c ∈ P<br />
{2.2.4 Gibt es einen Cube c mit Positivem δK(c)<br />
(Kostenersparnis) und innerhalb der Limits: True- dann<br />
setze den c mit Max(δK(c)) dem aktuellen Set zu; False –<br />
dann schließe das Set ab}<br />
if (∀ c ∈ P ∃ max(δK(c))>0)and(Limitreached(c)=false)<br />
then<br />
Begin;<br />
MatCube.add(c)//Addiere den Cube zum aktuellen Set<br />
{2.2.4.1 Gibt es noch NewSetsForEachIteration Cubes,<br />
welche das Limit erfüllen dann wähle die<br />
NewSetsForEachIteration besten Cubes und eröffne neue Sets<br />
solange bis MaxSets erreicht.}<br />
for counter:=1 to Settiefe do begin;<br />
setcount:=setcount+1;<br />
If setcount
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
{Ende 2.2.4.1 Gibt es noch NewSetsForEachIteration Cubes,<br />
welche das Limit erfüllen dann wähle die<br />
NewSetsForEachIteration besten Cubes und eröffne neue Sets<br />
solange bis MaxSets erreicht.}<br />
End //Ende von if (∀ c ∈ P ∃ max(δK(c))>0) and<br />
(Limitreached(c)=false)<br />
else limitreached:=true;<br />
//Else abbrechen: Gibt es keinen Cube, welcher einen<br />
positiven Kostenbeitrag bringt und in das Limit passt,<br />
dann schließe das Set ab.<br />
{Ende 2.4 Gibt es einen Cube c mit Positivem δK(c)<br />
(Kostenersparnis) und innerhalb der Limits: True- dann<br />
setze den c mit Max(δK(c)) dem aktuellen Set zu; False –<br />
dann schließe das Set ab}<br />
End;//Ende von limitreached=false<br />
{Ende 2.2. Der Iteration des aktuellen Sets}<br />
Sets[Setcounter]:=MatCube;<br />
//Merke dir das neue Set der Materialisierten Würfel<br />
in Sets[Setcounter]<br />
Setcounter:=Setcounter+1;<br />
//Setze den Zeiger auf das nächste Set<br />
Until Setcounter>=MaxSets;<br />
//Die Schleife läuft so lange bis die maximale Anzahl<br />
von Sets (MaxSets – wird vom Benutzer festgelegt)<br />
kontrolliert ist<br />
{Ende 2. Iterationen der Sets}<br />
- 133 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
{3. Berechne die Gesamtkosten für jedes Set}<br />
For Setcounter:=0 to Setcount do begin<br />
CalculateCostsforEachSet(Sets);<br />
End;<br />
{Ende 3. Berechne die Gesamtkosten für jedes Set}<br />
{4. Materialisiere jenes Set mit den minimalen Kosten}<br />
Materialize Set MinCosts(Sets);<br />
{Ende 4. Materialisiere jenes Set mit den minimalen Kosten}<br />
7.6.7.2 BESCHREIBUNG DER HEURISTIK<br />
Zu Beginn wird die Menge P der Possible Cubes berechnet, welche alle Required Cubes<br />
und alle Parent Cubes (Vorgänger der Required Cubes – somit ist der Required Cube<br />
ein Derivative des Parent Cubes) umfasst. Dann wird MaxSets als die Menge der zu<br />
kontrollierenden Sets und NewSetsforEachIteration als Anzahl der neuen Sets pro<br />
Iterationsschritt durch den Benutzer definiert. Der Parameter Setcounter gibt die<br />
Nummer des aktuelle betrachteten Cubesets an und Setcount gibt die Anzahl der bereits<br />
berechneten Cubesets an.<br />
Nach der Vorbereitungsphase wird die Schleife für die Iterationen gestartet<br />
Costimproofment<br />
∑<br />
x∈A(<br />
c)<br />
max<br />
− getbuild<br />
{ 0,<br />
[ getquery(<br />
min(<br />
P(<br />
x)<br />
, x)<br />
− getquery(<br />
c,<br />
x)<br />
) ] * Anz }<br />
( min(<br />
P(<br />
c)<br />
) , c)<br />
c<br />
=<br />
7.6.7.3 DEMONSTRATIVES BEISPIEL<br />
In diesem Abschnitt wird ein demonstratives Beispiel für die Funktionsweise der<br />
Heuristik gegeben. Dabei gehen wir von dem in Abbildung 48 angeführten APA aus.<br />
Die Eingabemaske des Input Screens mit den Dimensionen und Hierarchien findet sich<br />
in Abbildung 47. Wir gehen dabei von einem APA mit 3 Dimensionen und zwei<br />
Hierarchiestufen in der ersten Dimension, drei Hierarchiestufen in der zweiten<br />
Dimension und drei Hierarchiestufen in der dritten Dimension aus. Das ergibt eine<br />
Anzahl von 23 potentiellen Cubes von diesen sind 9 Required Cubes. Das Ergebnis der<br />
Heuristik wird in Abbildung 48 dargestellt. Die Anzahl der maximal möglichen Sets<br />
wurde mit 20 definiert und die maximal mögliche neue Setanzahl pro Iterationsschritt<br />
- 134 -<br />
x
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
wurde mit 4 definiert. Im Vorfeld darf jedoch vorweggenommen werden, dass die<br />
Limits so gewählt wurden, dass sich eine Lösung von 6 Cubes ergibt und nur 18<br />
mögliche Lösungswege vorhanden sind. Im Beispiel liefert die Heuristik eine 100 %<br />
richtige Lösung.<br />
Abbildung 47: Dimensionen und Hierarchien des DemoAPA<br />
Abbildung 48: DemoAPA mit Lösung<br />
Die Heuristik beginnt mit der Auswahl der Possible Cubes und dem Starten der<br />
Iteration. Im ersten Durchlauf wird der Fokus auf das Set 1 gesetzt, welches leer ist.<br />
- 135 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Dann beginnt die Iteration. Im ersten Iterationsschritt wird der Gewinn der<br />
Materialisierung eines jeden Cubes unabhängig von den anderen Cubes berechnet. Als<br />
bester Cube (mit der höchsten Gesamtkostenverringerung) würde der Cube 1:3<br />
festgestellt und dem Set 1 zugesetzt.<br />
1. Schritt: Finde den ersten Cube im aktuellen Set (1)<br />
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7 Costs<br />
1 1:3<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
11<br />
12<br />
13<br />
14<br />
15<br />
16<br />
17<br />
18<br />
19<br />
20<br />
Abbildung 49: Schritt 1 der Heuristik nach Thomas ACHS<br />
Als nächstes beginnt die Phase des Zusetzens der nächstbesten Cubes. Dabei wird der<br />
zweitbeste Cube dem Set 2, der drittbeste Cube dem Set 3,der viertbeste Cube dem Set<br />
4 und der fünftbeste Cube dem Set 5 als erster Cube zugesetzt bis entweder kein anderer<br />
Cube einen positiven Kostenbeitrag in der aktuellen Iterationsstufe liefern kann oder die<br />
maximale Anzahl der Cubes, welche zugesetzt werden dürfen<br />
(NewSetsForEachIteration – wird durch den Benutzer definiert) erreicht ist.<br />
- 136 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
2. Schritt: Zusetzen des zweitbesten bis fünftbesten Cubes in neue Sets,<br />
wenn sie positiven Nutzen haben und in das Limit passen<br />
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7 Costs<br />
1 1:3<br />
2 0:3<br />
3 1:4<br />
4 2:3<br />
5 0:5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
11<br />
12<br />
13<br />
14<br />
15<br />
16<br />
17<br />
18<br />
19<br />
20<br />
Abbildung 50: Schritt 2 der Heuristik nach Thomas ACHS<br />
Im Schritt 3 ist nun die erste Iteration abschlossen und nun wird im nächsten Schritt der<br />
Wert aller Cubes unter Berücksichtigung dessen, dass der Cube 1:3 bereits im Set 1<br />
materialisiert wurde, berechnet und der beste ausgewählt. Dies ist der Cube 1:4.<br />
3. Schritt: Finde den nächsten Cube im aktuellen Set (1)<br />
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7 Costs<br />
1 1:3 1:4<br />
2 0:3<br />
3 1:4<br />
4 2:3<br />
5 0:5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
11<br />
12<br />
13<br />
14<br />
15<br />
16<br />
17<br />
18<br />
19<br />
20<br />
Abbildung 51: Schritt 3 der Heuristik nach Thomas ACHS<br />
Dann werden die Sets mit den zweitbesten, drittbesten, usw. Cubes als Cube 2<br />
zugesetzt. An Position 1 steht der beste Cube des ersten Sets.<br />
- 137 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
4. Schritt: Eröffne neue Sets mit den zweitbesten bis fünftbesten Cubes<br />
in Position 2, wenn sie positiven Nutzen haben und in das Limit passen<br />
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7 Costs<br />
1 1:3 1:4<br />
2 0:3<br />
3 1:4<br />
4 2:3<br />
5 0:5<br />
6 1:3 2:3<br />
7 1:3 0:5<br />
8 1:3 0:3<br />
9 1:3 2:4<br />
10<br />
11<br />
12<br />
13<br />
14<br />
15<br />
16<br />
17<br />
18<br />
19<br />
20<br />
Abbildung 52: Schritt 4 der Heuristik nach Thomas ACHS<br />
Beim dritten Iterationsschritt kristallisiert sich der Cube 2:0 als beste Cube für das Set 1<br />
heraus. Deshalb wird dieser dem Set 1 zugesetzt.<br />
5. Schritt: Finde nächsten Cube im aktuellen Set (1)<br />
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7 Costs<br />
1 1:3 1:4 2:0<br />
2 0:3<br />
3 1:4<br />
4 2:3<br />
5 0:5<br />
6 1:3 2:3<br />
7 1:3 0:5<br />
8 1:3 0:3<br />
9 1:3 2:4<br />
10<br />
11<br />
12<br />
13<br />
14<br />
15<br />
16<br />
17<br />
18<br />
19<br />
20<br />
Abbildung 53: Schritt 5 der Heuristik nach Thomas ACHS<br />
Im Anschluss werden wiederum die neuen Sets mit dem nächstbesten Cubes in Phase 3<br />
zugesetzt. Dabei ist zu beachten, dass die ersten beiden Cubes aus dem Set 1<br />
übernommen werden und nur in der letzten Position die nächstbesten Cube zugesetzt<br />
werden.<br />
- 138 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
6. Schritt: Eröffne neue Sets mit den zweitbesten bis fünftbesten Cubes<br />
in Position 3, wenn sie positiven Nutzen haben und in das Limit passen<br />
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7 Costs<br />
1 1:3 1:4 2:0<br />
2 0:3<br />
3 1:4<br />
4 2:3<br />
5 0:5<br />
6 1:3 2:3<br />
7 1:3 0:5<br />
8 1:3 0:3<br />
9 1:3 2:4<br />
10 1:3 1:4 0:3<br />
11 1:3 1:4 1:2<br />
12 1:3 1:4 0:5<br />
13 1:3 1:4 0:0<br />
14<br />
15<br />
16<br />
17<br />
18<br />
19<br />
20<br />
Abbildung 54: Schritt 6 der Heuristik nach Thomas ACHS<br />
In Abbildung 55 (7. Schritt) wird die vierte Iteration gestartet und der Cube 1:2 als der<br />
nächste beste Cube gefunden und dem Set zugesetzt.<br />
7. Schritt: Finde nächsten Cube im aktuellen Set (1)<br />
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7 Costs<br />
1 1:3 1:4 2:0 1:2<br />
2 0:3<br />
3 1:4<br />
4 2:3<br />
5 0:5<br />
6 1:3 2:3<br />
7 1:3 0:5<br />
8 1:3 0:3<br />
9 1:3 2:4<br />
10 1:3 1:4 0:3<br />
11 1:3 1:4 1:2<br />
12 1:3 1:4 0:5<br />
13 1:3 1:4 0:0<br />
14<br />
15<br />
16<br />
17<br />
18<br />
19<br />
20<br />
Abbildung 55: Schritt 7 der Heuristik nach Thomas ACHS<br />
Abermals werden die nächsten besten Cubes in Schritt 8 in den neuen Sets hinzugefügt.<br />
- 139 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
8. Schritt: Eröffne neue Sets mit den zweitbesten bis fünftbesten Cubes<br />
in Position 4, wenn sie positiven Nutzen haben und in das Limit passen<br />
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7 Costs<br />
1 1:3 1:4 2:0 1:2<br />
2 0:3<br />
3 1:4<br />
4 2:3<br />
5 0:5<br />
6 1:3 2:3<br />
7 1:3 0:5<br />
8 1:3 0:3<br />
9 1:3 2:4<br />
10 1:3 1:4 0:3<br />
11 1:3 1:4 1:2<br />
12 1:3 1:4 0:5<br />
13 1:3 1:4 0:0<br />
14 1:3 1:4 2:0 0:5<br />
15 1:3 1:4 2:0 0:0<br />
16 1:3 1:4 2:0 2:2<br />
17 1:3 1:4 2:0 1:5<br />
18<br />
19<br />
20<br />
Abbildung 56: Schritt 8 der Heuristik nach Thomas ACHS<br />
Im fünften Iterationsschritt wird der Cube 2:2 als bester gefunden. Dieser wird zugesetzt<br />
und die Kontrolle der nächstbesten Cubes gestartet.<br />
9. Schritt: Finde nächsten Cube im aktuellen Set (1)<br />
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7 Costs<br />
1 1:3 1:4 2:0 1:2 2:2<br />
2 0:3<br />
3 1:4<br />
4 2:3<br />
5 0:5<br />
6 1:3 2:3<br />
7 1:3 0:5<br />
8 1:3 0:3<br />
9 1:3 2:4<br />
10 1:3 1:4 0:3<br />
11 1:3 1:4 1:2<br />
12 1:3 1:4 0:5<br />
13 1:3 1:4 0:0<br />
14 1:3 1:4 2:0 0:5<br />
15 1:3 1:4 2:0 0:0<br />
16 1:3 1:4 2:0 2:2<br />
17 1:3 1:4 2:0 1:5<br />
18<br />
19<br />
20<br />
Abbildung 57: Schritt 9 der Heuristik nach Thomas ACHS<br />
Die maximale Anzahl der Sets wurde vom Benutzer mit 20 Sets definiert. Dadurch ist<br />
nach dem Zusetzen des zweitbesten Cubes zum Set 18, des drittbesten Cubes zum Set<br />
19 und des vierbesten Cubes zum Set 20 keine weiteren Sets.<br />
- 140 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
10. Schritt: Eröffne neue Sets mit den zweitbesten bis fünftbesten<br />
Cubes in Position 5, wenn sie positiven Nutzen haben (Hinweis: Nach<br />
dem Set 20 ist die maximale Anzahl der Sets erreicht. Neue Sets werden<br />
nur so lange eröffnet, solange es Cubes gibt, die eine positiven Nutzen<br />
bringen und in das Limit passen oder die Anzahl der maximalen Sets<br />
erreicht ist. Deshalb werden keine neuen Sets mehr eröffnet)<br />
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7 Costs<br />
1 1:3 1:4 2:0 1:2 2:2<br />
2 0:3<br />
3 1:4<br />
4 2:3<br />
5 0:5<br />
6 1:3 2:3<br />
7 1:3 0:5<br />
8 1:3 0:3<br />
9 1:3 2:4<br />
10 1:3 1:4 0:3<br />
11 1:3 1:4 1:2<br />
12 1:3 1:4 0:5<br />
13 1:3 1:4 0:0<br />
14 1:3 1:4 2:0 0:5<br />
15 1:3 1:4 2:0 0:0<br />
16 1:3 1:4 2:0 2:2<br />
17 1:3 1:4 2:0 1:5<br />
18 1:3 1:4 2:0 1:2 1:5<br />
19 1:3 1:4 2:0 1:2 2:4<br />
20 1:3 1:4 2:0 1:2 3:2<br />
Abbildung 58: Schritt 10 der Heuristik nach Thomas ACHS<br />
Damit ist die Aufbauphase der Sets abgeschlossen und es erfolgt die Berechnungsphase<br />
für das aktuelle und alle folgenden Sets. Im Moment befinden wir uns noch im Set 1<br />
und suchen den nächsten Cube, welcher den besten Beitrag bringt und in die Limits<br />
passt. Dieser ist 2:4.<br />
11. Schritt: Finde nächsten Cube im aktuellen Set (1)<br />
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7 Costs<br />
1 1:3 1:4 2:0 1:2 2:2 2:4<br />
2 0:3<br />
3 1:4<br />
4 2:3<br />
5 0:5<br />
6 1:3 2:3<br />
7 1:3 0:5<br />
8 1:3 0:3<br />
9 1:3 2:4<br />
10 1:3 1:4 0:3<br />
11 1:3 1:4 1:2<br />
12 1:3 1:4 0:5<br />
13 1:3 1:4 0:0<br />
14 1:3 1:4 2:0 0:5<br />
15 1:3 1:4 2:0 0:0<br />
16 1:3 1:4 2:0 2:2<br />
17 1:3 1:4 2:0 1:5<br />
18 1:3 1:4 2:0 1:2 1:5<br />
19 1:3 1:4 2:0 1:2 2:4<br />
20 1:3 1:4 2:0 1:2 3:2<br />
Abbildung 59: Schritt 11 der Heuristik nach Thomas ACHS<br />
- 141 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Im Schritt 12 finden wir den Cube 2:3 als siebenten Cube des Sets 1, welcher den<br />
höchsten positiven Beitrag zu Kostenverringerung bringt und in die Limits passt.<br />
12. Schritt: Finde nächsten Cube im aktuellen Set (1)<br />
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7 Costs<br />
1 1:3 1:4 2:0 1:2 2:2 2:4 2:3<br />
2 0:3<br />
3 1:4<br />
4 2:3<br />
5 0:5<br />
6 1:3 2:3<br />
7 1:3 0:5<br />
8 1:3 0:3<br />
9 1:3 2:4<br />
10 1:3 1:4 0:3<br />
11 1:3 1:4 1:2<br />
12 1:3 1:4 0:5<br />
13 1:3 1:4 0:0<br />
14 1:3 1:4 2:0 0:5<br />
15 1:3 1:4 2:0 0:0<br />
16 1:3 1:4 2:0 2:2<br />
17 1:3 1:4 2:0 1:5<br />
18 1:3 1:4 2:0 1:2 1:5<br />
19 1:3 1:4 2:0 1:2 2:4<br />
20 1:3 1:4 2:0 1:2 3:2<br />
Abbildung 60: Schritt 12 der Heuristik nach Thomas ACHS<br />
Nach dem Zusetzen des siebenten Cubes findet sich kein Cube mehr, welcher einen<br />
positiven Beitrag bringt und in die Limits passt. Deshalb wird das Set 1 als<br />
abgeschlossen betrachtet und der Fokus auf das Set 2 gelegt.<br />
13. Schritt:Limit im Set 1 erreicht. Setze den Setcounter+1 (=2).<br />
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7 Costs<br />
1 1:3 1:4 2:0 1:2 2:2 2:4 2:3<br />
2 0:3<br />
3 1:4<br />
4 2:3<br />
5 0:5<br />
6 1:3 2:3<br />
7 1:3 0:5<br />
8 1:3 0:3<br />
9 1:3 2:4<br />
10 1:3 1:4 0:3<br />
11 1:3 1:4 1:2<br />
12 1:3 1:4 0:5<br />
13 1:3 1:4 0:0<br />
14 1:3 1:4 2:0 0:5<br />
15 1:3 1:4 2:0 0:0<br />
16 1:3 1:4 2:0 2:2<br />
17 1:3 1:4 2:0 1:5<br />
18 1:3 1:4 2:0 1:2 1:5<br />
19 1:3 1:4 2:0 1:2 2:4<br />
20 1:3 1:4 2:0 1:2 3:2<br />
Abbildung 61: Schritt 13 der Heuristik nach Thomas ACHS<br />
Da nun das Set 2 den Fokus hat, wird analog zum Set 1 immer der beste Cube zugesetzt,<br />
welcher in die Limits passt.<br />
- 142 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
14. Schritt:Berechne das noch vorhandene Limit nach der<br />
Berücksichtigung der bereits im neuen Set enthaltenen Cubes und<br />
starte die Iteration des neuen Sets.<br />
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7 Costs<br />
1 1:3 1:4 2:0 1:2 2:2 2:4 2:3<br />
2 0:3<br />
3 1:4<br />
4 2:3<br />
5 0:5<br />
6 1:3 2:3<br />
7 1:3 0:5<br />
8 1:3 0:3<br />
9 1:3 2:4<br />
10 1:3 1:4 0:3<br />
11 1:3 1:4 1:2<br />
12 1:3 1:4 0:5<br />
13 1:3 1:4 0:0<br />
14 1:3 1:4 2:0 0:5<br />
15 1:3 1:4 2:0 0:0<br />
16 1:3 1:4 2:0 2:2<br />
17 1:3 1:4 2:0 1:5<br />
18 1:3 1:4 2:0 1:2 1:5<br />
19 1:3 1:4 2:0 1:2 2:4<br />
20 1:3 1:4 2:0 1:2 3:2<br />
Abbildung 62: Schritt 14 der Heuristik nach Thomas ACHS<br />
Dies wird so lange durchgeführt bis kein Cube mehr dem Set 2 zugesetzt werden kann<br />
und der Fokus wandert auf das Set 3 usw.<br />
15. Schritt: Finde nächsten Cube im aktuellen Set (2)<br />
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7 Costs<br />
1 1:3 1:4 2:0 1:2 2:2 2:4 2:3<br />
2 0:3 1:3<br />
3 1:4<br />
4 2:3<br />
5 0:5<br />
6 1:3 2:3<br />
7 1:3 0:5<br />
8 1:3 0:3<br />
9 1:3 2:4<br />
10 1:3 1:4 0:3<br />
11 1:3 1:4 1:2<br />
12 1:3 1:4 0:5<br />
13 1:3 1:4 0:0<br />
14 1:3 1:4 2:0 0:5<br />
15 1:3 1:4 2:0 0:0<br />
16 1:3 1:4 2:0 2:2<br />
17 1:3 1:4 2:0 1:5<br />
18 1:3 1:4 2:0 1:2 1:5<br />
19 1:3 1:4 2:0 1:2 2:4<br />
20 1:3 1:4 2:0 1:2 3:2<br />
Abbildung 63: Schritt 15 der Heuristik nach Thomas ACHS<br />
Im Schritt 95 sehen wir das bereits fast vollendete Lösungsgitter der Sets 1 bis 20. Das<br />
Set 20 wird im Schritt 97 endgültig abgeschlossen.<br />
- 143 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
95. Schritt: Finde nächsten Cube im aktuellen Set (20)<br />
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7 Costs<br />
1 1:3 1:4 2:0 1:2 2:2 2:4 2:3<br />
2 0:3 1:3 1:4 2:0 1:2 2:4 2:3<br />
3 1:4 1:3 2:3 2:0 1:2 2:2 2:4<br />
4 2:3 1:3 1:4 2:0 1:2 2:2 2:4<br />
5 0:5 1:3 1:4 2:0 2:2 2:4 2:3<br />
6 1:3 2:3 0:3 1:4 2:0 1:2 2:4<br />
7 1:3 0:5 1:4 2:0 2:2 2:4 2:3<br />
8 1:3 0:3 1:4 2:0 1:2 2:4 2:3<br />
9 1:3 2:4 2:3 2:0 1:2 2:2<br />
10 1:3 1:4 0:3 2:3 2:0 1:2 2:4<br />
11 1:3 1:4 1:2 2:0 2:2 2:4 2:3<br />
12 1:3 1:4 0:5 2:3 0:3 2:0 2:4<br />
13 1:3 1:4 0:0 2:0 2:4 2:3<br />
14 1:3 1:4 2:0 0:5 2:3 2:4 2:2<br />
15 1:3 1:4 2:0 0:0 1:0 2:4 2:3<br />
16 1:3 1:4 2:0 2:2 1:2 2:4 2:3<br />
17 1:3 1:4 2:0 1:5 2:4 1:2 2:3<br />
18 1:3 1:4 2:0 1:2 1:5 2:4 2:3<br />
19 1:3 1:4 2:0 1:2 2:4 2:2 2:3<br />
20 1:3 1:4 2:0 1:2 2:4 2:2<br />
Abbildung 64: Schritt 95 der Heuristik nach Thomas ACHS<br />
96. Schritt: Finde nächsten Cube im aktuellen Set (20)<br />
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7 Costs<br />
1 1:3 1:4 2:0 1:2 2:2 2:4 2:3<br />
2 0:3 1:3 1:4 2:0 1:2 2:4 2:3<br />
3 1:4 1:3 2:3 2:0 1:2 2:2 2:4<br />
4 2:3 1:3 1:4 2:0 1:2 2:2 2:4<br />
5 0:5 1:3 1:4 2:0 2:2 2:4 2:3<br />
6 1:3 2:3 0:3 1:4 2:0 1:2 2:4<br />
7 1:3 0:5 1:4 2:0 2:2 2:4 2:3<br />
8 1:3 0:3 1:4 2:0 1:2 2:4 2:3<br />
9 1:3 2:4 2:3 2:0 1:2 2:2<br />
10 1:3 1:4 0:3 2:3 2:0 1:2 2:4<br />
11 1:3 1:4 1:2 2:0 2:2 2:4 2:3<br />
12 1:3 1:4 0:5 2:3 0:3 2:0 2:4<br />
13 1:3 1:4 0:0 2:0 2:4 2:3<br />
14 1:3 1:4 2:0 0:5 2:3 2:4 2:2<br />
15 1:3 1:4 2:0 0:0 1:0 2:4 2:3<br />
16 1:3 1:4 2:0 2:2 1:2 2:4 2:3<br />
17 1:3 1:4 2:0 1:5 2:4 1:2 2:3<br />
18 1:3 1:4 2:0 1:2 1:5 2:4 2:3<br />
19 1:3 1:4 2:0 1:2 2:4 2:2 2:3<br />
20 1:3 1:4 2:0 1:2 3:2 2:4 2:3<br />
Abbildung 65: Schritt 96 der Heuristik nach Thomas ACHS<br />
- 144 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
97. Schritt:Limit im Set 20 erreicht. Setze den Setcounter+1 (=21).<br />
Setcounter überschreitet die Anzahl der Sets (Setcount). Deshalb<br />
beende die Iterationsphase.<br />
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7 Costs<br />
1 1:3 1:4 2:0 1:2 2:2 2:4 2:3<br />
2 0:3 1:3 1:4 2:0 1:2 2:4 2:3<br />
3 1:4 1:3 2:3 2:0 1:2 2:2 2:4<br />
4 2:3 1:3 1:4 2:0 1:2 2:2 2:4<br />
5 0:5 1:3 1:4 2:0 2:2 2:4 2:3<br />
6 1:3 2:3 0:3 1:4 2:0 1:2 2:4<br />
7 1:3 0:5 1:4 2:0 2:2 2:4 2:3<br />
8 1:3 0:3 1:4 2:0 1:2 2:4 2:3<br />
9 1:3 2:4 2:3 2:0 1:2 2:2<br />
10 1:3 1:4 0:3 2:3 2:0 1:2 2:4<br />
11 1:3 1:4 1:2 2:0 2:2 2:4 2:3<br />
12 1:3 1:4 0:5 2:3 0:3 2:0 2:4<br />
13 1:3 1:4 0:0 2:0 2:4 2:3<br />
14 1:3 1:4 2:0 0:5 2:3 2:4 2:2<br />
15 1:3 1:4 2:0 0:0 1:0 2:4 2:3<br />
16 1:3 1:4 2:0 2:2 1:2 2:4 2:3<br />
17 1:3 1:4 2:0 1:5 2:4 1:2 2:3<br />
18 1:3 1:4 2:0 1:2 1:5 2:4 2:3<br />
19 1:3 1:4 2:0 1:2 2:4 2:2 2:3<br />
20 1:3 1:4 2:0 1:2 2:4 2:2 2:3<br />
Abbildung 66: Schritt 97 der Heuristik nach Thomas ACHS<br />
Nachdem alle Sets im Schritt 97 abgeschlossen sind, erfolgt die Kostenberechnung für<br />
jedes Set separat. Dabei wird die Materialisierungsreihenfolge der Cubes entsprechend<br />
eine kostenminimalen Materialisierung berechnet. Deshalb haben auch das Set 1, 3 , 4,<br />
11, 16 und 19 die gleichen Kosten, da es sich im Prinzip um die gleiche Menge an<br />
Cubes handelt, nur in unterschiedlicher Reihenfolge. Die Heuristik berechnet aber die<br />
Kosten immer in der Reihenfolge der minimalen Materialisierungskosten einer Menge.<br />
Aus diesem Grund müssen die gleichen Kosten entstehen.<br />
- 145 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
98. Berechne die Kosten für jedes Set. Diese bestehen aus den<br />
Materialisierungskosten pro Set und den Abfragekosten der Required<br />
Cubes beeinflusst durch die Auswahl des Sets.<br />
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7 Costs<br />
1 1:3 1:4 2:0 1:2 2:2 2:4 2:3 155.136,00<br />
2 0:3 1:3 1:4 2:0 1:2 2:4 2:3 561.381,00<br />
3 1:4 1:3 2:3 2:0 1:2 2:2 2:4 155.136,00<br />
4 2:3 1:3 1:4 2:0 1:2 2:2 2:4 155.136,00<br />
5 0:5 1:3 1:4 2:0 2:2 2:4 2:3 484.339,00<br />
6 1:3 2:3 0:3 1:4 2:0 1:2 2:4 561.381,00<br />
7 1:3 0:5 1:4 2:0 2:2 2:4 2:3 484.339,00<br />
8 1:3 0:3 1:4 2:0 1:2 2:4 2:3 561.381,00<br />
9 1:3 2:4 2:3 2:0 1:2 2:2 135.898,00<br />
10 1:3 1:4 0:3 2:3 2:0 1:2 2:4 561.381,00<br />
11 1:3 1:4 1:2 2:0 2:2 2:4 2:3 155.136,00<br />
12 1:3 1:4 0:5 2:3 0:3 2:0 2:4 966.857,00<br />
13 1:3 1:4 0:0 2:0 2:4 2:3 1.483.283,00<br />
14 1:3 1:4 2:0 0:5 2:3 2:4 2:2 484.339,00<br />
15 1:3 1:4 2:0 0:0 1:0 2:4 2:3 1.478.603,00<br />
16 1:3 1:4 2:0 2:2 1:2 2:4 2:3 155.136,00<br />
17 1:3 1:4 2:0 1:5 2:4 1:2 2:3 333.905,00<br />
18 1:3 1:4 2:0 1:2 1:5 2:4 2:3 333.905,00<br />
19 1:3 1:4 2:0 1:2 2:4 2:2 2:3 155.136,00<br />
20 1:3 1:4 2:0 1:2 3:2 2:4 2:3 468.248,00<br />
Abbildung 67: Schritt 98 der Heuristik nach Thomas ACHS<br />
Anschließend wird das Set mit den minimalen Kosten materialisiert. Dieses ist in<br />
unserem Beispiel das Set 9 mit den minimalen Kosten von 135898.<br />
99. Wähle das kostengünstigste Set und materialisiere das Set.<br />
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7 Costs<br />
1 1:3 1:4 2:0 1:2 2:2 2:4 2:3 155.136,00<br />
2 0:3 1:3 1:4 2:0 1:2 2:4 2:3 561.381,00<br />
3 1:4 1:3 2:3 2:0 1:2 2:2 2:4 155.136,00<br />
4 2:3 1:3 1:4 2:0 1:2 2:2 2:4 155.136,00<br />
5 0:5 1:3 1:4 2:0 2:2 2:4 2:3 484.339,00<br />
6 1:3 2:3 0:3 1:4 2:0 1:2 2:4 561.381,00<br />
7 1:3 0:5 1:4 2:0 2:2 2:4 2:3 484.339,00<br />
8 1:3 0:3 1:4 2:0 1:2 2:4 2:3 561.381,00<br />
9 1:3 2:4 2:3 2:0 1:2 2:2 135.898,00<br />
10 1:3 1:4 0:3 2:3 2:0 1:2 2:4 561.381,00<br />
11 1:3 1:4 1:2 2:0 2:2 2:4 2:3 155.136,00<br />
12 1:3 1:4 0:5 2:3 0:3 2:0 2:4 966.857,00<br />
13 1:3 1:4 0:0 2:0 2:4 2:3 1.483.283,00<br />
14 1:3 1:4 2:0 0:5 2:3 2:4 2:2 484.339,00<br />
15 1:3 1:4 2:0 0:0 1:0 2:4 2:3 1.478.603,00<br />
16 1:3 1:4 2:0 2:2 1:2 2:4 2:3 155.136,00<br />
17 1:3 1:4 2:0 1:5 2:4 1:2 2:3 333.905,00<br />
18 1:3 1:4 2:0 1:2 1:5 2:4 2:3 333.905,00<br />
19 1:3 1:4 2:0 1:2 2:4 2:2 2:3 155.136,00<br />
20 1:3 1:4 2:0 1:2 3:2 2:4 2:3 468.248,00<br />
Abbildung 68: Schritt 99 der Heuristik nach Thomas ACHS<br />
- 146 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.7 DIE DETERMINISTISCHE LÖSUNG<br />
7.7.1 MATHEMATISCHE GRUNDLAGEN<br />
Im Zuge der Bestimmung der deterministischen Lösung ist es notwendig, für alle<br />
möglichen Mengen von materialisieren Cubes die Kosten zu berechnen und die Menge<br />
auszuwählen, welche die geringsten Kosten hat. Dabei spielt die Rangfolge der<br />
materialisierten Cubes in der Menge eine Rolle. Spielt die Anordnung der Elemente in<br />
einer Menge eine Rolle, nennt man diese eine Folge [vgl. Witt (2001) S. 137]. Wenn der<br />
Cube a vor dem Cube b materialisiert wurde und b ein Derivative von a ist, die<br />
Materialisierungskosten für die Folge < a ,b > geringer sind als die<br />
Materialisierungskosten < b,a >. Das führt dazu, dass die Materialisierungssequenz von<br />
enormer Bedeutung sein kann.<br />
7.7.1.1 PERMUTATION<br />
Wir betrachten dabei die Auswahl von Folgen, in denen ein Element höchstens einmal<br />
vorkommen darf. Dies ist schlüssig, da ein Würfel nur einmal materialisiert werden<br />
kann. Bei dieser speziellen Art der Permutation spricht man von der Permutation ohne<br />
Wiederholung [vgl. Witt (2001) S. 137].<br />
Sei M eine Menge mit M = n und<br />
∈ . Ein k-Permutation von M ist eine Folge<br />
n<br />
k N0<br />
< k > x x 1 ,..., mit xi ∈ M und xi ≠ x j für i ≠ j , mit 1 ≤ i, j ≤ k . Weiters sei P ( n,<br />
k)<br />
die<br />
Anzahl der k-Permutationen, die aus n-elementigen Menge gebildet werden kann.<br />
[vgl. Witt (2001) S. 137f]<br />
n k 1 n!<br />
P(<br />
n,<br />
k)<br />
= n(<br />
n −1)(<br />
n − 2)...(<br />
n − k + 1)<br />
= ∏i = ∏ ( n − i)<br />
=<br />
( n − k)!<br />
−<br />
7.7.1.2 KOMBINATION<br />
- 147 -<br />
i=<br />
n−k<br />
+ 1<br />
Im Gegensatz zur Permutation spielt bei der Kombination die Reihenfolge der Elemente<br />
in der Menge keine Rolle. Wir gehen wieder von der Kombination ohne Wiederholung<br />
aus, was bedeutet, dass jedes Element in der Menge nur einmal vorkommt.<br />
Sei M eine Menge mit M = n und<br />
n<br />
k N0<br />
i=<br />
0<br />
∈ . Ein k-Kombination von M ist eine<br />
Teilmenge von M mit k Elementen. Weiters sei K ( n,<br />
k)<br />
die Anzahl der k-<br />
Kombinationen, die aus der Menge M gebildet werden können.<br />
n!<br />
K(<br />
n,<br />
k)<br />
=<br />
k!*(<br />
n − k)!
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
[vgl. Witt (2001) S. 141f]<br />
7.7.2 DER ALGORITHMUS FÜR DIE PERMUTATION<br />
{1. Vorbereitungen für die Permutation}<br />
Erzeuge Menge R der Required Cubes<br />
Erzeuge Menge P der Possible Cubes, welche die Menge der<br />
nicht redundanten Würfel umfasst und gib jedem Würfel einen<br />
Nummer.<br />
Erzeuge Countliste (array of longint) als die Teilmenge der<br />
Menge P mit den Nummern der Possible Cubes.<br />
anzcube=count(P) //Gibt die Anzahl der Elemente in der<br />
Menge P der Possible Cubes an.<br />
Alwaysspacemaxreached=true//Abbruchbedingung<br />
Cubepos=1<br />
maxpos=0<br />
aktpos=0<br />
{Ende 1. Vorbereitungen für die Permutation}<br />
if (anzcube>0) then begin<br />
{2. Beginn der Permutationsschleife}<br />
ende=false<br />
While (ende=false) do begin<br />
{2.1. Beginn der Unterpermutationsschleife für den letzten<br />
Zähler}<br />
Repeat<br />
if (Cubepos>anzcube) then begin<br />
{2.1.1 Wenn in der aktuellen Cursorposition das Maximum<br />
erreicht ist}<br />
- 148 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Cubepos=1<br />
Countliste[aktpos]=cubepos;<br />
aktpos=aktpos+1<br />
if aktpos>maxpos then maxpos=aktpos<br />
if aktposanzcube then begin<br />
if cubepos>anzcube then begin<br />
cubepos=1<br />
Countliste[aktpos]:=cubepos<br />
aktpos=aktpos+1<br />
if aktpos>maxpos then maxpos=aktpos<br />
end;<br />
if Countliste[aktpos]=0 then begin<br />
//Neue Zählung<br />
if Alwaysspacemaxreached=true then ende=true<br />
// Wenn alle Cubes dieses Durchlaufs z.B. 8<br />
Cubes das Speichermax überschritten haben<br />
hat es keinen Sinn auch noch 9 Cubes zu<br />
kontrollieren.<br />
Alwaysspacemaxreached=true<br />
cubepos=1<br />
Countliste[aktpos]=Cubepos<br />
end else begin<br />
//Springe auf gespeicherte Position<br />
Countliste[aktpos]= Countliste[aktpos]+1<br />
Cubepos=Countliste[aktpos]<br />
end<br />
until (Cubepos
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Cubepos=1<br />
aktpos:=0<br />
Countliste[aktpos]=Cubepos<br />
end //Ende if (cubeposanzcube)<br />
end //Ende if aktposanzcube)<br />
else<br />
begin // Beginn von if (Cubepos>anzcube)=false<br />
{2.1.2 Wenn in der aktuellen Cursorposition das Maximum<br />
nicht erreicht}<br />
aktpos=0;<br />
istok=true<br />
//Feststellen,ob jedes Element in der Folge nur<br />
einmal vorkommt<br />
for zahler:=0 to maxpos do begin<br />
//Es wird von der Position bis zum Ende<br />
kontrolliert da die ersten Positionen schon<br />
verglichen wurden<br />
for zahler2:=zahler to maxpos do begin<br />
if ((zahler2zahler)and<br />
(Countliste[zahler2]=Countliste[zahler]))<br />
then<br />
istok=false<br />
end // von for zahler2<br />
end // von for zahler<br />
if istok=true then begin<br />
- 150 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Spaceleft=spaceleft(Countliste)<br />
//Feststellen des Speicherplatzes nach der<br />
Materialisierung vom Countliste<br />
Spaceleftfirstcubes=<br />
spaceleft(Countliste[0..maxpos-1])<br />
//Berechnen von spacemax von allen Würfeln<br />
ausser dem aktuellen Würfel. Das heißt bei<br />
z.B. 8 Cubes wird nur der spaceleft von<br />
Cube 1 bis 7 berechnet<br />
if Spaceleftfirstcubes0) then begin<br />
Alwaysspacemaxreached=false<br />
kostenmerk=<br />
KostenfuerSetberechnen(Countliste)<br />
if (kostenmerk>0) then begin<br />
if (kostenmerk
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
End//Ende von If (spaceleft>0)<br />
end //Ende von istok<br />
Cubepos=Cubepos+1<br />
Countliste[aktpos]=Cubepos<br />
{Ende 2.1.2 Wenn in der aktuellen Cursorposition das<br />
Maximum nicht erreicht ist}<br />
end //Ende von if (Cubepos>anzcube)=false<br />
until (Cubepos>anzcube)<br />
{Ende 2.1. Ende der Unterpermutationsschleife für den<br />
letzten Zähler}<br />
End;<br />
{Ende 2. Beginn der Permutationsschleife}<br />
End //von if (anzcube>0)<br />
7.7.3 DER ALGORITHMUS FÜR DIE KOMBINATION<br />
{1. Vorbereitungen für die Kombination}<br />
Erzeuge Menge R der Required Cubes<br />
Erzeuge Menge P der Possible Cubes, welche die Menge der<br />
nicht redundanten Würfel umfasst und gib jedem Würfel einen<br />
Nummer.<br />
Erzeuge Countliste (array of longint) als die Teilmenge der<br />
Menge P mit den Nummern der Possible Cubes.<br />
Mincosts=0<br />
anzcube=count(P) //Gibt die Anzahl der Elemente in der<br />
Menge P der Possible Cubes an.<br />
- 152 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
{Ende 1. Vorbereitungen für die Kombination}<br />
{2. Algorithmus für die Kombination}<br />
lang=0 //gibt den aktuellen Wert für k (Anzahl der<br />
Kombinationen an – lang=k-1)<br />
Countliste[0]=1; //Startwert für die Kombination ist der<br />
Cube 1<br />
Ende=false; //Abbruchwert<br />
{2.2. Laufe durch die Kombination bis ende=true}<br />
repeat;<br />
alwaysspacemaxreached:=true;<br />
//Wenn alle Kombinationen von z.B. 7 Cubes das<br />
Speicherlimit überschreiten, wird auch eine<br />
Kombination von 8 Cubes den Speicherwert jedenfalls<br />
überschreiten. Darum Abbruch bei<br />
alwaysspacemaxreached.<br />
aktpos=0 //Gibt den Cursor auf das erste Element der<br />
Countliste<br />
istok=true<br />
{2.2.1 Durchlaufe alle Kombinationen mit dem aktuellen<br />
lang Wert}<br />
repeat //(neuespalte=true)or(ende=true)<br />
neuespalte=false<br />
{2.2.1.1 Istok=true}<br />
if (istok=true) then begin<br />
Spaceleft=spaceleft(Countliste)<br />
//Feststellen des Speicherplatzes nach der<br />
Materialisierung vom Countliste<br />
Spaceleftfirstcubes=<br />
spaceleft(Countliste[0..maxpos-1])<br />
//Berechnen von spacemax von allen Würfeln<br />
ausser dem aktuellen Würfel. Das heißt bei<br />
z.B. 8 Cubes wird nur der spaceleft von<br />
Cube 1 bis 7 berechnet<br />
- 153 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if Spaceleftfirstcubes0) then begin<br />
Alwaysspacemaxreached=false<br />
Getrightorder(Countliste)<br />
//Stelle die kostenminimale Reihenfolge<br />
der Cubes mit einem abwandelten<br />
Algorithmus von Dijkstra her<br />
kostenmerk=<br />
KostenfuerSetberechnen(Countliste)<br />
if (kostenmerk>0) then begin<br />
if (kostenmerk0)<br />
End //Ende von if (istok=true)<br />
{Ende 2.2.1.1 Istok=true}<br />
{2.2.1.2. Ist in der aktuellen Position (aktpos) das<br />
Maximum erreicht oder nicht}<br />
- 154 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if countliste[aktpos]>=(anzcube-aktpos) then<br />
begin<br />
{2.2.1.2.1 Setze alle cubes vom aktpos und kleiner auf 1}<br />
Countliste[aktpos]=1<br />
x=aktpos<br />
repeat<br />
Countliste[x]=1<br />
x=x-1;<br />
until x=-1<br />
{Ende 2.2.1.2.1 Setze alle cubes vom aktpos und kleiner auf<br />
1}<br />
aktpos=aktpos+1<br />
if countliste[aktpos]=0 then<br />
neuespalte=true<br />
Countliste[aktpos]:=countliste[aktpos]+1<br />
{2.2.1.2.2. Finde den nächsten Cube, welcher nicht das<br />
Maximum hat}<br />
repeat;<br />
if Countliste[aktpos]>(anzcube-aktpos)<br />
then begin<br />
aktpos=aktpos+1<br />
if (aktpos>anzcube) then begin<br />
aktpos=anzcube<br />
ende=true<br />
end<br />
if Countliste[aktpos]=0 then<br />
neuespalte=true<br />
Countliste[aktpos]=<br />
Countliste[aktpos]+1<br />
end<br />
until (Countliste[aktpos]
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
x=aktpos-1<br />
istok=true<br />
repeat<br />
if x>=0 then begin<br />
Countliste[x]=Countliste[x+1]+1<br />
end<br />
x=x-1<br />
until x=(anzcubeaktpos)<br />
else begin<br />
Countliste[aktpos]=countliste[aktpos]+1<br />
aktpos=0<br />
end<br />
{Ende 2.2.1.2. Ist in der aktuellen Position (aktpos) das<br />
Maximum erreicht oder nicht}<br />
until (neuespalte=true)or(ende=true)<br />
{Ende 2.2.1. Durchlaufe alle Kombinationen mit dem<br />
aktuellen lang Wert}<br />
if alwaysspacemaxreached=true then ende=true<br />
lang=lang+1<br />
until (ende=true)or(lang>anzcube)<br />
{Ende 2.2. Laufe durch die Kombination bis ende=true}<br />
7.7.4 DER ALGORITHMUS DER FUNKTION GETRIGHTORDER<br />
Cost<br />
x<br />
=<br />
∑<br />
z∈A(<br />
x)<br />
max<br />
{ 0,<br />
[ getbuild(<br />
min(<br />
P(<br />
z)<br />
, z)<br />
− getbuild(<br />
x,<br />
z)<br />
) ] }<br />
Empfange Parameter Listecubes als Menge der zu<br />
materialisierten und zu ordnenden Cubes<br />
- 156 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Definiere die Knoten mittels<br />
Knotendeklationszeiger= ^Knotendeklaration als Zeiger<br />
auf ein Record<br />
Knotendeklaration =<br />
record<br />
Knoten:longint;<br />
spalte:longint;<br />
zeile:longint;<br />
MaxAbstand:Extended;<br />
Parent:longint;<br />
end;<br />
Definiere Randknoten als Menge von Knoten<br />
Definiere Innere_Knoten als Menge von Knoten<br />
{1. Erzeuge die Menge der Randknoten und berechne die<br />
Kosten}<br />
for zahler:=0 to Listecubes.Count-1 do begin<br />
//Die Cubes können nur aus dem BFT erzeugt werden<br />
Kostengewinn:=0;<br />
for zahler2:=0 to Listecubes.count-1 do begin<br />
if (isderivat(Listecubes[zahler].spalte,<br />
Listecubes[zahler].zeile,<br />
Listecubes[zahler2].spalte,<br />
Listecubes[zahler2].zeile)=true) then begin<br />
//Der Kostengewinn ergibt sich daraus,<br />
dass sich die Derivative zahler2 in<br />
Zukunft aus dem Cube zahler ableiten<br />
lässen.<br />
Kostengewinn=Kostengewinn+<br />
(//Da noch kein Würfel materialisiert<br />
wurde, werden alle vom BFT erzeugt<br />
max(0,getbuild(-1,-1,<br />
Listecubes[zahler2].spalte,<br />
Listecubes[zahler2].zeile))getbuild(Listecubes[zahler].spalte,<br />
Listecubes[zahler].zeile),<br />
Listecubes[zahler2].spalte,<br />
Listecubes[zahler2].zeile)))<br />
- 157 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
end; //isderivat(…<br />
end // von zahler2<br />
//Erzeugen und Speichern des Cube<br />
New(Knoten)<br />
Knoten^.Knoten=zahler;<br />
Knoten^.MaxAbstand=Kostengewinn;<br />
Knoten^.Parent=-1;<br />
Knoten^.spalte= Listecubes[zahler].spalte<br />
Knoten^.zeile= Listecubes[zahler].zeile<br />
Randknoten.Add(Knoten);<br />
end;<br />
{Ende 1. Erzeuge die Menge der Randknoten und berechne die<br />
Kosten}<br />
{2. Durchlaufen der Randknoten bis die Menge der Randknoten<br />
leer ist und alle Knoten in der Menge der Innere_Knoten<br />
sind.}<br />
repeat<br />
{ 2.1.Feststellen des neuen Randknotens mit dem minmalen<br />
Abstand und Überstellen dieses Knotens von den Randknoten<br />
zu den Inneren Knoten}<br />
zahlermerk:=-1;costmerk:=0;<br />
for zahler=0 to Randknoten.Count-1 do begin<br />
Knoten= Randknoten.Items[zahler]<br />
if (Knoten^.MaxAbstand>costmerk) or(zahlermerk=-1) then<br />
begin<br />
zahlermerk=zahler<br />
costmerk:=Knoten^.MaxAbstand;<br />
end;<br />
end;<br />
//Zusetzen des Würfels zu Inneren Knoten<br />
- 158 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Knotenmerk=Randknoten.Items[zahlermerk];<br />
Innere_Knoten.Add(Knotenmerk);<br />
Randknoten.Delete(zahlermerk);<br />
{Ende 2.1.Feststellen des neuen Randknotens und Überstellen<br />
dieses Knotens von den Randknoten zu den Inneren Knoten}<br />
if Randknoten.Count>0 then begin<br />
{2.2. Durchlaufe die aktuelle Menge der Randknoten}<br />
for zahler=0 to Randknoten.count-1 do begin<br />
Knoten= Randknoten.items[zahler];<br />
{2.2.1 Stelle fest, ob die Randknoten Derivative von dem<br />
neuen Inneren Knoten sind. Wenn ja und die Kosten sind<br />
geringer als die vom BFT, dann ändere Kosten. Ist jedoch<br />
der neue Innere Cube ein Derivative von dem Randknoten,<br />
müssen die Kosten neu berechnet werden.}<br />
if<br />
(isderivat(Knotenmerk^.spalte,Knotenmerk^.zeile,<br />
Knoten^.spalte,Knoten^.zeile)=true) or<br />
(isderivat(Knoten^.spalte,Knoten^.zeile,<br />
Knotenmerk^.spalte,Knotenmerk^.zeile)=true)<br />
then begin<br />
{2.2.1.1 Durchlaufe alle Randknoten und suche Parent}<br />
Kostengewinn:=0;<br />
for zahler2:=0 to Randknoten.Count-1 do begin<br />
Knoten2:=Randknoten.Items[zahler2]<br />
//Stelle fest, ob dieser Randknoten ein Derivat ist<br />
if (isderivat(Knoten^.spalte,Knoten^.zeile,<br />
Knoten2^.spalte,Knoten2.zeile)=true)<br />
and(Knoten^.KnotenKnoten2^.Knoten) then begin<br />
//Finde das Kostenminimale Parent von Knoten2<br />
Parentvonderivat=-1<br />
Parentvonderivatcostmerk:=getbuild(-1,-1,<br />
Knoten2.spalte,Knoten2^.zeile)<br />
for zahler3:=0 to Innere_Knoten.count-1 do begin<br />
- 159 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Knoten3:=Innere_Knoten.Items[zahler3]<br />
if (isderivat(Knoten3^.spalte,Knoten3^.zeile,<br />
Knoten2^.spalte,Knoten2^.zeile)=true)and<br />
(Knoten3^.KnotenKnotenmerk^.Knoten)and<br />
(Knoten3^.KnotenKnotenmerk^.Knoten)then begin<br />
costmerk:=getbuild(Knoten3^.spalte,<br />
Knoten3^.zeile, Knoten2^.spalte,<br />
Knoten2^.zeile)<br />
if (costmerk
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
der neue Innere Cube ein Derivative von dem Randknoten,<br />
müssen die Kosten neu berechnet werden}<br />
end //zahler<br />
{Ende 2.2. Durchlaufe die aktuelle Menge der Randknoten}<br />
end // Ende von Randknoten.count>0<br />
until Randknoten.Count=0<br />
{Ende 2. Durchlaufen der Randknoten bis die Menge der<br />
Randknoten leer ist und alle Knoten in der Menge der<br />
Innere_Knoten sind.}<br />
{3. Übergebe die Sequenz der Inneren Randknoten}<br />
Result:=Innere_Randknoten<br />
{Ende 3. Übergebe die Sequenz der Inneren Randknoten}<br />
7.7.5 DER ALGORITHMUS DER FUNKTION<br />
KOSTENFUERSETBERECHNEN<br />
Diese Funktion berechnet die Kosten eines an die Funktion übergebenen Menge von<br />
Materialisierten Würfel und einer an die Funktion übergebenen Menge von Required<br />
Cubes. Dabei werden die Materialisierungs- und die Abfragekosten berechnet und<br />
zurückgegeben. Wird das Zeitlimit der Materialisierung überschritten, wird als Wert 0<br />
zurückgeben.<br />
Empfange Parameter MatCubes als Menge der zu<br />
materialiserten Cubes<br />
Empfange Parameter ReqCubes als Menge der required Cubes<br />
{1. Feststellen, ob die Cubes die Spacemaxbedingung<br />
erfüllen}<br />
spaceleft=calculatespacemaxof(Countliste)<br />
timeleft=Maxavailabletime<br />
{Ende 1. Feststellen, ob die Cubes die Spacemaxbedingung<br />
erfüllen}<br />
- 161 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if spaceleft>0 then begin<br />
{2. Kosten berechnen}<br />
SummeKosten=0<br />
{2.1 Ersten Cube zusetzen}<br />
aktspalte=MemoryCubes[Countliste[0]].spalte<br />
//Spaltenwert des ersten Cubes<br />
aktzeile=MemoryCubes[Countliste[0]].zeile<br />
//Zeilenwert des ersten Cubes<br />
newcosts=getbuild(-1,-1,aktspalte,aktzeile)<br />
//Der erste Cube wird aus dem BFT (-1,-1) erzeugt.<br />
Deshalb sind die newcosts gleich den<br />
Materialisierungskosten aus dem BFT<br />
SummeKosten=SummeKosten+newcosts<br />
Memorywuerfel.Add(aktspalte,aktzeile)<br />
timemax=timemax-newcosts //Vermindere Timemax um die<br />
Materialisierungszeit des ersten Cube<br />
{Ende 2.1 Ersten Cube zusetzen}<br />
{2.2 Weitere Cubes zusetzen}<br />
for x= 1 to Maxpos do begin<br />
aktspalte:=MemoryCubes[Countliste[x]].spalte;<br />
aktzeile:=MemoryCubes[Countliste[x]].zeile;<br />
{2.2.1 Kann der Cube aus einem bereits materialisierten<br />
Cube abgeleitet werden}<br />
if isderivatof(Memorywuerfel)=true then begin<br />
newminderivatspalte:=GetMinDerivatOfSpalte(aktspa<br />
lte,aktzeile)<br />
newminderivatzeile:=GetMinDerivatOfZeile(aktspalt<br />
e,<br />
aktzeile)<br />
newcosts=getbuild(newminderivatspalte,<br />
newminderivatzeile,aktspalte,aktzeile);<br />
SummeKosten=SummeKosten+newcosts<br />
Memorywuerfel.Add(aktspalte,aktzeile);<br />
timemax:=timemax-newcosts<br />
- 162 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
end<br />
{Ende 2.2.1 Kann der Cube aus einem bereits<br />
materialisierten Cube abgeleitet werden}<br />
{2.2.2 Der Cube kann nicht aus einem bereits<br />
materialisierten Cube abgeleitet werden}<br />
else begin<br />
newcosts=getbuild(-1,-1,aktspalte,aktzeile)<br />
SummeKosten=SummeKosten+newcosts<br />
Memorywuerfel.Add(aktspalte,aktzeile);<br />
timemax:=timemax-newcosts<br />
end<br />
{Ende 2.2.2 Der Cube kann nicht aus einem bereits<br />
materialisierten Cube abgeleitet werden}<br />
end //Ende von for x=1 …<br />
{Ende 2.2 Weitere Cubes zusetzen}<br />
{2.3 Berechnen der Kosten für die Abfragen aller Required<br />
Cubes}<br />
for zahler=0 to MemoryReqCubescount.count-1 do begin<br />
spalte=MemoryReqCubes[zahler].spalte<br />
zeile=MemoryReqCubes[zahler].zeile<br />
{2.3.1. Wenn der Cube aus den materialisierten Cubes<br />
abgefragt werden kann}<br />
if isderivatof(Memorywuerfel)=true then begin<br />
newminderivatspalte=<br />
GetMinDerivatOfSpalte(spalte,zeile)<br />
newminderivatzeile= GetMinDerivatOfZeile(spalte,zeile)<br />
newcosts= ((getquery( newminderivatspalte,<br />
newminderivatzeile, spalte, zeile))<br />
*APA[spalte,zeile].gewicht);//Häufigkeit der Abfrage<br />
(globale Variable APA)<br />
SummeKosten=SummeKosten+newcosts<br />
end<br />
{Ende 2.3.1. Wenn der Cube aus den materialisierten Cubes<br />
abgefragt werden kann}<br />
{2.3.2. Wenn der Cube nur aus dem BFT abgefragt werden<br />
kann}<br />
- 163 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
else begin<br />
newcosts=((getquery(-1,-1,spalte,zeile))<br />
*APA[spalte,zeile].gewicht) //Häufigkeit der<br />
Abfrage (globale Variable APA)<br />
SummeKosten=SummeKosten+newcosts<br />
End<br />
{Ende 2.3.2. Wenn der Cube nur aus dem BFT abgefragt werden<br />
kann}<br />
end;<br />
{Ende 2.3 Berechnen der Kosten für die Abfragen aller<br />
Required Cubes}<br />
{Ende 2. Kosten berechnen}<br />
if (timemax0<br />
{3. Übergeben der Kosten}<br />
Result=SummeKosten<br />
Spaceleft=spacemax //Globale Variable spaceleft<br />
Timeleft=timemax //Globale Variable timeleft<br />
{Ende 3. Übergeben der Kosten}<br />
7.8 DIE ENTWICKLUNGSUMGEBUNG UND DIE APPLIKATION<br />
7.8.1 AUSWAHL DER ENTWICKLUNGSUMGEBUNG<br />
Die Auswahl der Entwicklungsumgebung ging mit der Auswahl des Betriebssystems<br />
analog. Das Ziel war natürlich eine Anwendung zu gestalten, welche auf möglichst<br />
vielen Betriebssystemen lauffähig ist. Die Hauptanwenderzielgruppe sind die Studenten<br />
der Wirtschaftsuniversität Wien, welche die Anwendung in den Seminaren als<br />
Fortbildungsinstrument nutzen sollen. Da die Rechner der Wirtschaftsuniversität auf<br />
Windows laufen wurde somit ein Windowslauffähiges Programm als<br />
Mindestanforderung an die Programmierumgebung definiert. Schließlich fiel die<br />
- 164 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Entscheidung auf eine im Besitz des Autors befindliche Version vom Borland Delphi<br />
(siehe auch www.borland.com) Version 7.0 for .NET. Dieser Softwarecompilier<br />
produziert sowohl Windows lauffähige Version, als auch, über Kylix compiliert, eine<br />
Linux lauffähige Version des Programms. Zusätzlich steht die Produktion der .NET<br />
fähigen Delphi Version Octane unmittelbar bevor. Dann wäre eine Compilierung auf<br />
.NET möglich.<br />
In den ersten Versionen des Programms wurde zusätzlich eine Datenbank integriert.<br />
Allerdings ist eine Installation eines Programms mit einem Datenbanktreiber auf den<br />
Rechner der Universität nur mit Administratorrechten möglich. Deshalb wurde die<br />
Datenbank wieder entfernt und auf eine Speicherung der Daten in einfachen Datenfiles<br />
mit eigener Indexprogrammierung ausgewichen.<br />
7.8.2 ENTWURF DER BENUTZERSCHNITTSTELLE<br />
Die Benutzerschnittstelle der Software soll in übersichtlicher Weise dem Benutzer –<br />
zumeist Studenten – die Möglichkeit bieten, das System des APA zu verstehen und ein<br />
Datawarehouse zu modellieren. Ich will dabei die wichtigsten modularen Schnittstellen<br />
kurz vorstellen.<br />
7.8.2.1 DAS HAUPTMENU<br />
Das Hauptmenü des APA Programmes ist übersichtlich gestaltet. Die wichtigsten<br />
Unterscreens des Programmes, der Input Screen, der APA Grid Screen und APA<br />
Selection Screen werden entsprechend der logischen Abfolge im Zentrum angeordenet.<br />
Zusätzlich gibt das Hauptmenü unter dem Punkt File die Möglichkeit APAs zu laden<br />
und zu speichern. Unter dem Menupunkt Screens können alle Screens separat<br />
aufgerufen werden. Der Punkt Berechnung ermöglicht das Erstellen der Zufallskosten<br />
und einige Analysetools für das APA Grid. Im Unterpunkt Settings ist es möglich, die<br />
Optionen für das Programm und die Parameter für die Heuristik bzw. die<br />
deterministische Lösung einzustellen. Im Menüpunkt Help findet man eine ausführliche<br />
Dokumentation des Software Tools, welches unerfahrenen Benutzern beim Einstieg in<br />
die Software begleiten soll.<br />
- 165 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 69: Das Hauptmenu des APA Programmes<br />
7.8.2.2 DIE EINGABEMASKE (INPUT SCREEN)<br />
Die Eingabemaske ermöglicht dem Benutzer das Eingeben und Ordnen der Dimension<br />
und Hierarchien. Zusätzlich werden die Key Figures eingegeben, welche für das<br />
Generieren der SQL Statements benötigt werden. Die Hierarchien werden mit der<br />
Anzahl ihrer Ausprägungen gespeichert. Dadurch können im Hintergrund<br />
Berechnungen über Tupelanzahl der einzelnen Tabellen durchgeführt werden.<br />
- 166 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 70: Der APA Input Screen<br />
7.8.2.3 DIE PRÄSENTATIONSMASKE (APA SCREEN)<br />
Die Präsentationsmaske des APA Grid ist das umfangreichste Modul im Programm. Es<br />
erlaubt dem Benutzer nicht nur das Betrachten und Analysieren des APA, sondern auch<br />
Ausführen einer Reihe von Analysetools und Anzeigen von Hintergrundinformation.<br />
Dabei können die Funktionen über das Hauptmenü oder für zellenbasierende<br />
Funktionen über das Popup Menu aufgerufen werden. Zusätzlich sind Buttons für<br />
häufige Funktionen unter dem Hauptmenü angeordnet.<br />
- 167 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 71: Die Präsentationsmaske des APA Grid<br />
7.8.2.4 DIE AUSWAHLMASKE DER REQUIRED CUBES (SELECTION<br />
SCREEN)<br />
Der APA Selection Screen soll den Benutzer unterstützen, die „Required Cubes“ im<br />
APA, welche für ihn interessant sind, zu finden. Dies ist besonders bei großen APAs<br />
mit zahlreichen Dimensionen und Hierarchiestufen von Bedeutung, da die<br />
Übersichtlichkeit durch Benutzen des APA Selection Screen bestehen bleibt. Zusätzlich<br />
können Roll Ups oder Drill Down über Dimensionen durchgeführt werden und in einem<br />
Eingabeschritt markiert werden.<br />
- 168 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 72: Die Auswahlmaske der Required Cubes<br />
7.8.3 DATENMODELLIERUNG DER APPLIKATION<br />
7.8.3.1 AUSWAHL DER DATENBANK<br />
Die Auswahl der Hauptdatenbank für die Applikation wurde auf den Vorschlag von<br />
Prof. Prosser mit Microsoft SQL fixiert. Das Ziel ist es nicht nur die Eingaben in die<br />
APA Software speichern zu können, sondern auch die CREATE TABLE Anweisungen<br />
für die BFT und Zusatztabellen (bei Fact Constellation Schema) zu generieren.<br />
Zusätzlich war mein Ansinnen jedoch, die Daten der Applikation für weitere<br />
Datenbanken (MySql, Paradox) und sogar als Textfile sichern zu können. Dies ist<br />
besonders für die weltweite Benutzung essentiell. Die Endversion des Programms<br />
wurde aber ohne eine Datenbankanbindung produziert, da die Installation der<br />
Datenbank auf der Universität nicht ohne Administratorrechte durchgeführt werden<br />
kann und das Ziel eine universell einsetzbare Anwendung im Vordergrund stand.<br />
Trotzdem sollte eine Endbenutzerversion des Programms mit eine leistungsfähigen<br />
Datenbank kombiniert werden. Dies ist besonders im vernetzten betrieblichen Einsatz<br />
notwendig, wo für den einzelnen Benutzer unterschiedliche Benutzerrechte gelten.<br />
- 169 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.8.3.2 SEMANTISCHE DATENMODELLIERUNG<br />
Die Semantische Datenmodellierung beschreibt die Daten als ER Diagramm. Das<br />
folgende ER-Diagramm soll die Grundlage der Daten in einer MS SQL Datenbank<br />
darstellen. Diese Datenbanken werden jedoch nicht von der im Anhang beschriebenen<br />
Software real verwendet, da diese im Lehrbetrieb auf der Wirtschaftsuniversität<br />
verwendet werden soll und das Anlegen von Benutzerrechten für jeden Studenten eine<br />
große administrative Aufgabenstellungen bedeuten würde. Allerdings will ich<br />
exemplarisch diese Variante durchdiskutieren. Sollte jedoch diese Software jemals zu<br />
einem Endanwenderprodukt für den Verkauf aufgewertet werden, bildete diese<br />
Datenmodellierung die Grundlage und gibt zusätzlich ein gutes demonstratives Beispiel<br />
für die klassische Datenmodellierung.<br />
- 170 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 73: ER-Diagramm für die APA Datenbank<br />
Das ER-Diagramm besteht aus einer Reihe von Entitäten und Beziehungen. Aus<br />
Gründen der besseren Übersicht und klaren Lesbarkeit wurden die Attribute in dieser<br />
Darstellung entfernt.<br />
Die Entität „Administrator“ steht mit der Entität „Benutzer“ in einer m:n Beziehung. Es<br />
soll ein Systemadministrator mehrere Benutzer bearbeiten können und ein Benutzer soll<br />
von mehreren Systemadministratoren bearbeitet werden können.<br />
Die Entität „Benutzer“ besitzt mehrere „Gitter“. Ein Benutzer kann also mehrere Data<br />
Warehouse Modelle parallel bearbeiten. Ein „Gitter“ wird aber immer nur einem<br />
Benutzer zugeordnet.<br />
- 171 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Das „Gitter“ enthält oder besteht aus vielen „Zellen“. Diese Zellen kann man sich<br />
ähnlich einer Zelle in einem Tabellenkalkulationsprogramm vorstellen. Die Entität<br />
„Zelle“ repräsentiert aber wiederum einen speziellen „Würfel“ (Cube) im<br />
multidimensionalen Data Warehouse. Wobei jede „Zelle“ immer nur einen „Würfel“<br />
repräsentieren kann.<br />
Ein „Würfel“ hat wiederum spezifische Eigenschaften, die ihn beschreiben. Er besteht<br />
aus einer Reihe von Dimensionen, die wiederum eine bestimmte Hierarchiestufe haben.<br />
Dies wird mit der „virtuellen“ Entität „Dimension auf einer Hierarchiestufe“<br />
ausgedrückt. Ein „Würfel“ kann sich aus mehreren Dimensionen mit einer bestimmten<br />
Hierarchiestufe zusammensetzen. Eine Dimension kann aber nur einmal in einem<br />
Würfel vorkommen. Deshalb ist die Beziehung zwischen der Entität „Würfel“ und der<br />
Entität „Dimension auf einer Hierarchiestufe“ eine 1:n Beziehung.<br />
Das „Gitter“ wird generiert aus mehreren „Dimensionen“, die wiederum mehrere<br />
„Hierarchiestufen“ haben können. Deshalb gibt es sowohl eine 1:n Beziehung zwischen<br />
der Entität „Gitter“ und „Dimensionen“, als auch zwischen der Entität „Dimensionen“<br />
und „Hierarchiestufen“.<br />
„Dimensionen“ werden mehrmals von der Entität „Dimension auf einer<br />
Hierarchiestufe“ verwendet. Die Entität „Dimension auf einer Hierarchiestufe“ kann<br />
aber nur eine Dimension haben. Ähnlich die Situation auf der Seite der<br />
Hierarchiestufen. Die Entität „Hierarchiestufe“ kann mehrmals in der Entität<br />
„Dimension auf einer Hierarchiestufe“ verwendet werden. Die Entität „Dimension auf<br />
einer Hierarchiestufe“ hat im Namen schon enthalten, dass die Dimension nur auf einer<br />
Hierarchiestufe sein kann.<br />
Zum Entwickeln der Benutzeranforderungen wurden zusätzlich noch 3 Entitäten in das<br />
ER-Diagramm eingefügt. Die Entität „Benutzeranforderungen“ repräsentiert<br />
unterschiedliche Benutzeranforderungen einem Gitter. Dies können Finanzkennzahlen,<br />
Lagerstandsabfragen, kundenbezogene Kennzahlen, etc. sein. Diese kann der Benutzer<br />
in der Entität „Benutzeranforderungen“ separat gruppieren und übersichtlich behandeln.<br />
Natürlich soll es dem Benutzer gestattet sein mehrere Benutzeranforderungen an ein<br />
Gitter zu stellen. Deshalb ist die Beziehung zwischen der Entität „Gitter“ und der Entität<br />
„Benutzeranforderungen“ eine 1:n Beziehung. Diese Benutzeranforderungen werden<br />
jedoch in mehrere Blöcke unterteilt, die wiederum aus mehreren Detailanforderungen<br />
bestehen können. Eine beispielhafte Detailanforderung wäre „Die Kunden gruppiert<br />
nach Bundesland“ (Das würde der Dimension „Kunden“ auf der Hierarchiestufe<br />
„Bundesland“ entsprechen). Ein fertiger Block wäre z.B. „Alle Umsätze der Kunden pro<br />
Bundesland (erste Detailanforderung), aller Artikeln (zweite Detailanforderung –<br />
höchste Hierarchiestufe der Artikeln) und in der Zeitspanne pro Monat mit einem „Roll-<br />
Up“ bis zum Jahr (dritte Detailanforderung).<br />
- 172 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Natürlich können nur wieder Dimensionen und Hierarchien für die Detailanforderungen<br />
verwendet werden, die in der Entität „Dimensionen“ bzw. in der Entität<br />
„Hierarchiestufen“ angelegt wurden. Dies wird durch die 1:n Beziehungen zwischen<br />
„Hierarchiestufen“ und „Detailanforderungen“ und „Dimensionen“ und<br />
„Detailanforderungen“ ausgedrückt.<br />
7.8.3.3 LOGISCHE DATENMODELLIERUNG<br />
Die Ableitung des APA Relationenmodells aus dem APA ER-Modells erfolgt analog<br />
nach der oben beschriebenen Standardvorgehensweise beim Entwickeln von<br />
relationalen Datenbanksystemen [vgl. Riordan (2000) S.149ff]. Die Entitäten wurden in<br />
Tabellen umgesetzt. Eine zusätzliche Tabelle wurde für die Beziehung zwischen<br />
Administratoren (APA_Admin) und Benutzern (APA_User) erzeugt. Die Umsetzung<br />
erfolgt mit dem Microsoft SQL 2000 Server. Auf Grund der Umsetzung des ER -<br />
Diagramms enthält die Datenbank folgende Tables mit Primärschlüsseln.<br />
- 173 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Table Beschreibung Primärschlüssel<br />
APA_Admin Administratoren AdminID<br />
Beziehung m:n Beziehung AdminID<br />
APA_Admin_User zwischen Administratoren<br />
und Benutzern<br />
UserID<br />
APA_User<br />
Benutzer und Besitzer des<br />
Gitters<br />
UserID<br />
APA_Dimension Dimensionen des Gitters<br />
GitterID<br />
DimensionID<br />
GitterID<br />
APA_Hierarchy<br />
Hierarchien der einzelnen<br />
Dimensionen eines Gitters<br />
DimensionID<br />
Hierarchylevel<br />
APA_Gitter Daten über das Gitter GitterID<br />
GitterID<br />
APA_Cells<br />
Zellen des Gitters und<br />
deren Daten<br />
Row<br />
Column<br />
GitterID<br />
APA_Cube<br />
Hierarchiestufen der<br />
Row<br />
einzelnen Dimensionen des<br />
Gitters<br />
Column<br />
DimensionID<br />
Anforderungsliste des GitterID<br />
APA_Req<br />
Benutzer für ein<br />
bestimmtes Gitter<br />
ReqID<br />
GitterID<br />
APA_ReqBlock<br />
Reqirement Block für jedes<br />
ReqID<br />
APA_req Objekt<br />
BlockID<br />
GitterID<br />
APA_Detailreq<br />
Detailanforderungen jedes<br />
Blocks<br />
ReqID<br />
BlockID<br />
DetailreqID<br />
Tabelle 10: : Beschreibung der Tables der APA Datenbank<br />
- 174 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 74: Ableitung des APA Relationenmodells aus dem APA ER-Modell<br />
- 175 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.8.3.4 PHYSISCHE DATENMODELLIERUNG<br />
Das physische Datenmodell beschreibt die Daten des Informationssystems auf der<br />
Ebene der technischen Implementierung. Das physische Datenmodell bezieht sich auf<br />
ein konkretes Datenbankprodukt. Im Zuge dieser Arbeit wird Microsoft SQL 2000<br />
Server als Datenbankprodukt fixiert. Im folgenden werde ich deshalb auf die konkreten<br />
physischen Ausprägungen im Sinne der „CREATE TABLE“ Anweisungen eingehen,<br />
welche auf den Notationen von Barth (2002) S. 127ff und Taylor (2001) S. 41 ff<br />
basieren.<br />
7.8.3.4.1 FORMALE SQL-ANWEISUNGEN LAUT SQL 99<br />
CREATE TABLE APA_Admin (<br />
AdminID INTEGER NOT NULL ,<br />
Admindescription VARCHAR(25) NOT NULL ,<br />
PRIMARY KEY (AdminID)<br />
);<br />
CREATE TABLE APA_Admin_User (<br />
AdminID INTEGER NOT NULL ,<br />
UserID INTEGER NOT NULL,<br />
PRIMARY KEY (AdminID, UserID)<br />
);<br />
CREATE TABLE APA_Cells (<br />
GitterID INTEGER NOT NULL ,<br />
Row INTEGER NOT NULL ,<br />
Column INTEGER NOT NULL ,<br />
Short_Description VARCHAR(8) NOT NULL ,<br />
Caption VARCHAR(8) NOT NULL ,<br />
DimensionID INTEGER NOT NULL ,<br />
HierarchyID INTEGER NOT NULL ,<br />
Interesting BIT NOT NULL ,<br />
Materialized BIT NOT NULL ,<br />
Derivative BIT NOT NULL ,<br />
Linetop BIT NOT NULL ,<br />
Linebottom BIT NOT NULL ,<br />
Lineleft BIT NOT NULL ,<br />
Lineright BIT NOT NULL ,<br />
Boldtop BIT NOT NULL ,<br />
Boldbottom BIT NOT NULL ,<br />
Boldleft BIT NOT NULL ,<br />
Boldright BIT NOT NULL,<br />
PRIMARY KEY (GitterID)<br />
);<br />
CREATE TABLE APA_Cube (<br />
- 176 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
GitterID INTEGER NOT NULL ,<br />
Row INTEGER NOT NULL ,<br />
Column INTEGER NOT NULL ,<br />
DimensionID INTEGER NOT NULL ,<br />
Hierarchylevel INTEGER NOT NULL,<br />
PRIMARY KEY (GitterID, Row, Column, DimensionID)<br />
);<br />
CREATE TABLE APA_Detailreq (<br />
GitterID INTEGER NOT NULL ,<br />
ReqID INTEGER NOT NULL ,<br />
BlockID INTEGER NOT NULL ,<br />
DetailReqID INTEGER NOT NULL ,<br />
DimensionID INTEGER NOT NULL ,<br />
Hierarchylevel INTEGER NOT NULL ,<br />
Methode VARCHAR(10),<br />
EndHierarchylevel INTEGER NULL,<br />
PRIMARY KEY (GitterID, RegID, BlockID, DetailreqID)<br />
);<br />
CREATE TABLE APA_Dimension (<br />
GitterID INTEGER NOT NULL ,<br />
DimensionID INTEGER NOT NULL ,<br />
Dimension_Description VARCHAR(40),<br />
PRIMARY KEY (GitterID, DimensionID)<br />
);<br />
CREATE TABLE APA_Gitter (<br />
GitterID INTEGER IDENTITY (1, 1) NOT NULL ,<br />
Description VARCHAR(40) NOT NULL ,<br />
UserID INTEGER NOT NULL ,<br />
Rowcount INTEGER NOT NULL ,<br />
Columncount INTEGER NOT NULL,<br />
PRIMARY KEY (GitterID)<br />
);<br />
CREATE TABLE APA_Hierarchy (<br />
GitterID INTEGER NOT NULL ,<br />
DimensionID INTEGER NOT NULL ,<br />
Hierarchylevel INTEGER NOT NULL ,<br />
Short_Description VARCHAR(8) NOT NULL ,<br />
Long_Description] VARCHAR(50),<br />
PRIMARY KEY (GitterID, DimensionID, Hierarchielevel)<br />
);<br />
CREATE TABLE APA_Req (<br />
GitterID INTEGER NOT NULL ,<br />
ReqID INTEGER IDENTITY (1, 1) NOT NULL ,<br />
ReqDecription VARCHAR(30),<br />
- 177 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
PRIMARY KEY (GitterID, RegID)<br />
);<br />
CREATE TABLE APA_ReqBlock (<br />
GitterID INTEGER NOT NULL ,<br />
ReqID INTEGER NOT NULL ,<br />
BlockID INTEGER IDENTITY (1, 1) NOT NULL ,<br />
Description VARCHAR (30),<br />
PRIMARY KEY (GitterID, ReqID, BlockID)<br />
);<br />
CREATE TABLE APA_User (<br />
UserID INTEGER IDENTITY (1, 1) NOT NULL ,<br />
Description VARCHAR(50) NOT NULL ,<br />
Password VARCHAR(15) NOT NULL,<br />
PRIMARY KEY (UserID)<br />
);<br />
7.8.3.4.2 MICROSOFT SQL SPEZIFISCHE SQL ANWEISUNGEN<br />
Jeder Datenbankhersteller unterstützt zwar SQL als Standard, verwendet aber leider oft<br />
eigene Dialekte und Formatsyntax für seine Datenbankprodukte. Um dem Rechnung zu<br />
tragen, dass meine Anwendung auf Microsoft SQL als Datenbank abzielt, will ich hier<br />
die spezifischen SQL Anweisungen, die auf Grund der in Abbildung 36 dargestellten<br />
relationalen Struktur entwickelt wurden, hier anführen. Zusätzlich zu den „CREATE<br />
TABLE“ Anweisungen werden im Script auch am Beginn überprüft, ob die Tabellen<br />
vorhanden sind (if exists) und gegebenenfalls gelöscht.<br />
Überprüfungen:<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[FK_APA_Admin_User_APA_Admin]') and<br />
OBJECTPROPERTY(id, N'IsForeignKey') = 1)<br />
ALTER TABLE [dbo].[APA_Admin_User] DROP CONSTRAINT<br />
FK_APA_Admin_User_APA_Admin<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[FK_APA_Cube_APA_Cells]') and<br />
OBJECTPROPERTY(id, N'IsForeignKey') = 1)<br />
ALTER TABLE [dbo].[APA_Cube] DROP CONSTRAINT<br />
FK_APA_Cube_APA_Cells<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[FK_APA_Cube_APA_Dimension]') and<br />
OBJECTPROPERTY(id, N'IsForeignKey') = 1)<br />
- 178 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
ALTER TABLE [dbo].[APA_Cube] DROP CONSTRAINT<br />
FK_APA_Cube_APA_Dimension<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[FK_APA_Detailreq_APA_Dimension]') and<br />
OBJECTPROPERTY(id, N'IsForeignKey') = 1)<br />
ALTER TABLE [dbo].[APA_Detailreq] DROP CONSTRAINT<br />
FK_APA_Detailreq_APA_Dimension<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[FK_APA_Hierarchy_APA_Dimension1]') and<br />
OBJECTPROPERTY(id, N'IsForeignKey') = 1)<br />
ALTER TABLE [dbo].[APA_Hierarchy] DROP CONSTRAINT<br />
FK_APA_Hierarchy_APA_Dimension1<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[FK_APA_Cells_APA_Gitter]') and<br />
OBJECTPROPERTY(id, N'IsForeignKey') = 1)<br />
ALTER TABLE [dbo].[APA_Cells] DROP CONSTRAINT<br />
FK_APA_Cells_APA_Gitter<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[FK_APA_Dimension_APA_Gitter]') and<br />
OBJECTPROPERTY(id, N'IsForeignKey') = 1)<br />
ALTER TABLE [dbo].[APA_Dimension] DROP CONSTRAINT<br />
FK_APA_Dimension_APA_Gitter<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[FK_APA_Req_APA_Gitter]') and<br />
OBJECTPROPERTY(id, N'IsForeignKey') = 1)<br />
ALTER TABLE [dbo].[APA_Req] DROP CONSTRAINT<br />
FK_APA_Req_APA_Gitter<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[FK_APA_Cube_APA_Hierarchy]') and<br />
OBJECTPROPERTY(id, N'IsForeignKey') = 1)<br />
ALTER TABLE [dbo].[APA_Cube] DROP CONSTRAINT<br />
FK_APA_Cube_APA_Hierarchy<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[FK_APA_Detailreq_APA_Hierarchy]') and<br />
OBJECTPROPERTY(id, N'IsForeignKey') = 1)<br />
- 179 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
ALTER TABLE [dbo].[APA_Detailreq] DROP CONSTRAINT<br />
FK_APA_Detailreq_APA_Hierarchy<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[FK_APA_Detailreq_APA_Hierarchy1]') and<br />
OBJECTPROPERTY(id, N'IsForeignKey') = 1)<br />
ALTER TABLE [dbo].[APA_Detailreq] DROP CONSTRAINT<br />
FK_APA_Detailreq_APA_Hierarchy1<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[FK_APA_ReqBlock_APA_Req]') and<br />
OBJECTPROPERTY(id, N'IsForeignKey') = 1)<br />
ALTER TABLE [dbo].[APA_ReqBlock] DROP CONSTRAINT<br />
FK_APA_ReqBlock_APA_Req<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[FK_APA_Detailreq_APA_ReqBlock]') and<br />
OBJECTPROPERTY(id, N'IsForeignKey') = 1)<br />
ALTER TABLE [dbo].[APA_Detailreq] DROP CONSTRAINT<br />
FK_APA_Detailreq_APA_ReqBlock<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[FK_APA_Admin_User_APA_User]') and<br />
OBJECTPROPERTY(id, N'IsForeignKey') = 1)<br />
ALTER TABLE [dbo].[APA_Admin_User] DROP CONSTRAINT<br />
FK_APA_Admin_User_APA_User<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[FK_APA_Gitter_APA_User]') and<br />
OBJECTPROPERTY(id, N'IsForeignKey') = 1)<br />
ALTER TABLE [dbo].[APA_Gitter] DROP CONSTRAINT<br />
FK_APA_Gitter_APA_User<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[APA_Admin]') and OBJECTPROPERTY(id,<br />
N'IsUserTable') = 1)<br />
drop table [dbo].[APA_Admin]<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[APA_Admin_User]') and OBJECTPROPERTY(id,<br />
N'IsUserTable') = 1)<br />
drop table [dbo].[APA_Admin_User]<br />
- 180 -
GO<br />
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[APA_Cells]') and OBJECTPROPERTY(id,<br />
N'IsUserTable') = 1)<br />
drop table [dbo].[APA_Cells]<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[APA_Cube]') and OBJECTPROPERTY(id,<br />
N'IsUserTable') = 1)<br />
drop table [dbo].[APA_Cube]<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[APA_Detailreq]') and OBJECTPROPERTY(id,<br />
N'IsUserTable') = 1)<br />
drop table [dbo].[APA_Detailreq]<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[APA_Dimension]') and OBJECTPROPERTY(id,<br />
N'IsUserTable') = 1)<br />
drop table [dbo].[APA_Dimension]<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[APA_Gitter]') and OBJECTPROPERTY(id,<br />
N'IsUserTable') = 1)<br />
drop table [dbo].[APA_Gitter]<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[APA_Hierarchy]') and OBJECTPROPERTY(id,<br />
N'IsUserTable') = 1)<br />
drop table [dbo].[APA_Hierarchy]<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[APA_Req]') and OBJECTPROPERTY(id,<br />
N'IsUserTable') = 1)<br />
drop table [dbo].[APA_Req]<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[APA_ReqBlock]') and OBJECTPROPERTY(id,<br />
N'IsUserTable') = 1)<br />
drop table [dbo].[APA_ReqBlock]<br />
GO<br />
- 181 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[APA_User]') and OBJECTPROPERTY(id,<br />
N'IsUserTable') = 1)<br />
drop table [dbo].[APA_User]<br />
GO<br />
CREATE TABLE Anweisungen:<br />
CREATE TABLE [dbo].[APA_Admin] (<br />
[AdminID] [int] NOT NULL ,<br />
[Admindescription] [char] (25) COLLATE<br />
Latin1_General_CI_AS NOT NULL<br />
) ON [PRIMARY]<br />
GO<br />
CREATE TABLE [dbo].[APA_Admin_User] (<br />
[AdminID] [int] NOT NULL ,<br />
[UserID] [int] NOT NULL<br />
) ON [PRIMARY]<br />
GO<br />
CREATE TABLE [dbo].[APA_Cells] (<br />
[GitterID] [int] NOT NULL ,<br />
[Row] [int] NOT NULL ,<br />
[Column] [int] NOT NULL ,<br />
[Short_Description] [char] (250) COLLATE<br />
Latin1_General_CI_AS NULL ,<br />
[Caption] [char] (8) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[DimensionID] [int] NOT NULL ,<br />
[HierarchyID] [int] NOT NULL ,<br />
[Interesting] [bit] NOT NULL ,<br />
[Materialized] [bit] NOT NULL ,<br />
[Derivative] [bit] NOT NULL ,<br />
[Linetop] [bit] NOT NULL ,<br />
[Linebottom] [bit] NOT NULL ,<br />
[Lineleft] [bit] NOT NULL ,<br />
[Lineright] [bit] NOT NULL ,<br />
[Boldtop] [bit] NOT NULL ,<br />
[Boldbottom] [bit] NOT NULL ,<br />
[Boldleft] [bit] NOT NULL ,<br />
[Boldright] [bit] NOT NULL<br />
) ON [PRIMARY]<br />
GO<br />
CREATE TABLE [dbo].[APA_Cube] (<br />
[GitterID] [int] NOT NULL ,<br />
[Row] [int] NOT NULL ,<br />
- 182 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
[Column] [int] NOT NULL ,<br />
[DimensionID] [int] NOT NULL ,<br />
[Hierarchylevel] [int] NOT NULL<br />
) ON [PRIMARY]<br />
GO<br />
CREATE TABLE [dbo].[APA_Detailreq] (<br />
[GitterID] [int] NOT NULL ,<br />
[ReqID] [int] NOT NULL ,<br />
[BlockID] [int] NOT NULL ,<br />
[DetailReqID] [int] NOT NULL ,<br />
[DimensionID] [int] NOT NULL ,<br />
[Hierarchylevel] [int] NOT NULL ,<br />
[Methode] [char] (10) COLLATE Latin1_General_CI_AS<br />
NULL ,<br />
[EndHierarchylevel] [int] NULL<br />
) ON [PRIMARY]<br />
GO<br />
CREATE TABLE [dbo].[APA_Dimension] (<br />
[GitterID] [int] NOT NULL ,<br />
[DimensionID] [int] NOT NULL ,<br />
[Dimension_Description] [char] (40) COLLATE<br />
Latin1_General_CI_AS NULL<br />
) ON [PRIMARY]<br />
GO<br />
CREATE TABLE [dbo].[APA_Gitter] (<br />
[GitterID] [int] IDENTITY (1, 1) NOT NULL ,<br />
[Description] [char] (40) COLLATE Latin1_General_CI_AS<br />
NOT NULL ,<br />
[UserID] [int] NOT NULL ,<br />
[Rowcount] [int] NOT NULL ,<br />
[Columncount] [int] NOT NULL<br />
) ON [PRIMARY]<br />
GO<br />
CREATE TABLE [dbo].[APA_Hierarchy] (<br />
[GitterID] [int] NOT NULL ,<br />
[DimensionID] [int] NOT NULL ,<br />
[Hierarchylevel] [int] NOT NULL ,<br />
[Short_Description] [char] (8) COLLATE<br />
Latin1_General_CI_AS NOT NULL ,<br />
[Long_Description] [char] (50) COLLATE<br />
Latin1_General_CI_AS NULL<br />
) ON [PRIMARY]<br />
GO<br />
CREATE TABLE [dbo].[APA_Req] (<br />
- 183 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
[GitterID] [int] NOT NULL ,<br />
[ReqID] [int] IDENTITY (1, 1) NOT NULL ,<br />
[ReqDecription] [char] (30) COLLATE<br />
Latin1_General_CI_AS NULL<br />
) ON [PRIMARY]<br />
GO<br />
CREATE TABLE [dbo].[APA_ReqBlock] (<br />
[GitterID] [int] NOT NULL ,<br />
[ReqID] [int] NOT NULL ,<br />
[BlockID] [int] IDENTITY (1, 1) NOT NULL ,<br />
[Description] [char] (30) COLLATE Latin1_General_CI_AS<br />
NULL<br />
) ON [PRIMARY]<br />
GO<br />
CREATE TABLE [dbo].[APA_User] (<br />
[UserID] [int] IDENTITY (1, 1) NOT NULL ,<br />
[Description] [char] (50) COLLATE Latin1_General_CI_AS<br />
NOT NULL ,<br />
[Password] [char] (15) COLLATE Latin1_General_CI_AS<br />
NOT NULL<br />
) ON [PRIMARY]<br />
GO<br />
7.8.3.5 GENERIEREN DER CREATE TABLE ANWEISUNGEN IN DER<br />
SOFTWARE<br />
Unsere Software kann dem Benutzer SQL-Scripts generieren, welche dieser direkt an<br />
einen Microsoft SQL Server schicken kann und damit die Tables, bzw. die Aggregate<br />
erzeugt werden. Dabei wollen wir die zwei einfachsten Schemata, das Star und das Fact<br />
Constellation Schema, umsetzen.<br />
7.8.3.5.1 DAS STAR-SCHEMA<br />
Das Star-Schema wird durch einen BFT, in welchem auch die Aggregate gespeichert<br />
werden, charakterisiert. Die Dimensionstabellen sind sternförmig um diesen BFT<br />
angeordnet. Wichtig ist das Level Attribut, da dieses eine Unterscheidung zwischen<br />
atomaren und aggregierten Daten erlaubt.<br />
- 184 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 75: Der Aufbau eines Star Schemas als Basis der CREATE TABLE Anweisungen<br />
I_Key C_Key P_Key Qty_Sold Revenue<br />
K0001 K00001 K000001 1000 1200<br />
K0001 K00001 K900001 19000 22800<br />
K0001 K00001 K999001 110100 110101<br />
K0001 K00002 K000001 700 840<br />
K0001 K00002 K000002 980 1470<br />
K0001 K00002 K900001 17890 21468<br />
K0001 K00003 K000001 900 1080<br />
K0002 K00001 K000001 1111 1667<br />
K0002 K00001 K000002 1100 1650<br />
K0002 K00001 K900001 17150 25725<br />
K0002 K00001 K999001 89600 134400<br />
K0003 K00001 K000002 10000 9000<br />
K0003 K00001 K900001 16900 15210<br />
K0003 K00001 K999001 96100 86490<br />
K0003 K00002 K000001 20000 18000<br />
K0003 K00003 K000001 4000 3600<br />
K5000 K00001 K000001 2111 2867<br />
K5000 K00002 K000001 700 840<br />
K5000 K00003 K000001 900 1080<br />
K5700 K00002 K000001 20000 18000<br />
K5700 K00003 K000001 4000 3600<br />
K9999 K00001 K000001 2111 2867<br />
K9999 K00002 K000001 20700 18840<br />
K9999 K00003 K000001 4900 4680<br />
K9999 K99999 K000001 27711 26387<br />
Tabelle 11: Beispielhafter BFT für die Anwendung<br />
- 185 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
C_Key C_cu C_description C_gr C_gr_description level address<br />
K00001 9876543 Woolworth 1 foodstore 0 207, View Rd, NSW, 9910<br />
K00002 9874321 K-Mart 1 foodstore 0 12, Creek Ave, NSW, 6677<br />
K00003 8912345 Mc Donalds 2 fastfood 0 403, Flood St, NSW, 1109<br />
K19999 * * 1 foodstore 1<br />
K29999 * * 2 fastfood 1<br />
K99999 * * * * 2<br />
Tabelle 12: Beispielhafter Customer-Dimensionstable für die Anwendung<br />
I_Key I_it I_description I_ty I_ty_description level<br />
K0001 1234567 Oranges Naval - S. A. 1 fruits 0<br />
K0002 12345789 Banana Rosa - Victoria 1 fruits 0<br />
K0003 2345678 Milk - Dairy Farmers 2 diary 0<br />
K5000 * * 1 fruits 1<br />
K5700 * * 2 diary 1<br />
K9999 * * * * 2<br />
Tabelle 13: Beispielhafter Items-Dimensionstable für die Anwendung<br />
P_Key P_d P_description P_m P_m_description P_y P_y_description level<br />
K000001 1 1-Jan-2000 1 Jan, 2000 1 2000 0<br />
K000002 2 2-Jan-2000 1 Jan, 2000 1 2000 0<br />
K000003 3 3-Jan-2000 1 Jan, 2000 1 2000 0<br />
K000170 170 18-Jun-2000 6 June, 2000 1 2000 0<br />
K000171 171 19-Jun-2000 6 June, 2000 1 2000 0<br />
K900001 * * 1 Jan, 2000 1 2000 1<br />
K900002 * * 2 Feb, 2000 1 2000 1<br />
K900003 * * 3 March, 2000 1 2000 1<br />
K900006 * * 6 June, 2000 1 2000 1<br />
K999001 * * * * 1 2000 2<br />
Tabelle 14: Beispielhafter Time-Dimensionstable für die Anwendung<br />
7.8.3.5.2 DAS FACT CONSTELLATION SCHEMA<br />
Bei Fact Constellation-Schema werden die Aggregate in separaten Fact Tables (FT)<br />
gespeichert. Das führt zu mehreren, aber kleineren Tabellen.<br />
- 186 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 76: Beispielhafte Auflistung der Dimension Tables und der Fact Tables beim Fact<br />
Constellation-Schema<br />
7.8.3.5.3 BEISPIELHAFTES UMSETZEN DER TABLES DURCH DAS PROGRAMM<br />
7.8.3.5.3.1 DIE AUSGANGSPOSITION<br />
Wir gehen für wie in 7.6.7.3 von einem Demo APA aus und domonstrieren die<br />
Ergebnisse der SQL Scripts. Unser APA hat 3 Dimensionen (Agenten, Kunden, und<br />
Zeit). Diese haben wiederum unterschiedliche Hierarchiestufen, welche in Abbildung<br />
77 im Detail aufgelistet sind. Zusätzlich haben wir den „Key figure“ Umsatz vom Typ<br />
- 187 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
Money.<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 77: Input Screen des Demo APA<br />
Die Heuristik ergibt das in Abbildung 78 angeführte Ergebnis. Dabei werden 6<br />
materialisierte Würfel erzeugt. Nun kann der BFT, die Dimension Tabellen und die<br />
aggregierten Views in unterschiedlichen physischen Tabellenstrukturen abgespeichert<br />
werden. Ich habe in der Software die Strukturen für das Star-Schema und das Fact<br />
Constellation-Schema integriert. Die Ergebnisse werden in den nachfolgenden Kapiteln<br />
aufgelistet. Dabei wird beim Star-Schema ein BFT und drei Dimension Tables erzeugt.<br />
Die materialisierten Würfel werden im BFT integriert und durch hinzufügen des Level-<br />
Attributes kann man durch Querys unterscheiden, ob es sich um atomare Daten oder<br />
einen aggregierten Würfel handelt. Beim Fact Constellation-Schema enthält der BFT<br />
nur die atomaren Daten. Die Dimensionstabellen enthalten zusätzlich<br />
Fremdschlüsselwerte für jede Hierarchiestufe. Die materialisierten Sichten werden in<br />
separaten Aggregated Fact Tables gespeichert.<br />
- 188 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 78: APA Grid Screen des Demo APA<br />
7.8.3.5.3.2 DIE SCRIPTS FÜR DAS STAR SCHEMA<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[FK_BFT_Agenten_table]')<br />
and OBJECTPROPERTY(id, N'IsForeignKey') = 1)<br />
ALTER TABLE [dbo].[BFT] DROP CONSTRAINT<br />
FK_BFT_Agenten_table<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[Agenten_table]') and<br />
OBJECTPROPERTY(id, N'IsUserTable') = 1)<br />
drop table [dbo].[Agenten_table]<br />
GO<br />
CREATE TABLE [dbo].[Agenten_table] (<br />
[Agenten_id] [varchar] (50) COLLATE<br />
Latin1_General_CI_AS NOT NULL ,<br />
[A_id] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[A_id_desc] [varchar] (40) COLLATE<br />
Latin1_General_CI_AS NOT NULL ,<br />
[A_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[A_*_desc] [varchar] (40) COLLATE Latin1_General_CI_AS<br />
NOT NULL ,<br />
[level] [bigint] NOT NULL<br />
) ON [PRIMARY]<br />
GO<br />
- 189 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
ALTER TABLE [dbo].[Agenten_table] WITH NOCHECK ADD<br />
CONSTRAINT [PK_Agenten_table] PRIMARY KEY CLUSTERED<br />
(<br />
[Agenten_id]<br />
) ON [PRIMARY]<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[FK_BFT_Kunden_table]')<br />
and OBJECTPROPERTY(id, N'IsForeignKey') = 1)<br />
ALTER TABLE [dbo].[BFT] DROP CONSTRAINT FK_BFT_Kunden_table<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[Kunden_table]') and<br />
OBJECTPROPERTY(id, N'IsUserTable') = 1)<br />
drop table [dbo].[Kunden_table]<br />
GO<br />
CREATE TABLE [dbo].[Kunden_table] (<br />
[Kunden_id] [varchar] (50) COLLATE<br />
Latin1_General_CI_AS NOT NULL ,<br />
[K_id] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[K_id_desc] [varchar] (40) COLLATE<br />
Latin1_General_CI_AS NOT NULL ,<br />
[K_gr] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[K_gr_desc] [varchar] (40) COLLATE<br />
Latin1_General_CI_AS NOT NULL ,<br />
[K_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[K_*_desc] [varchar] (40) COLLATE Latin1_General_CI_AS<br />
NOT NULL ,<br />
[level] [bigint] NOT NULL<br />
) ON [PRIMARY]<br />
GO<br />
ALTER TABLE [dbo].[Kunden_table] WITH NOCHECK ADD<br />
CONSTRAINT [PK_Kunden_table] PRIMARY KEY CLUSTERED<br />
(<br />
[Kunden_id]<br />
) ON [PRIMARY]<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[FK_BFT_Zeit_table]')<br />
and OBJECTPROPERTY(id, N'IsForeignKey') = 1)<br />
- 190 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
ALTER TABLE [dbo].[BFT] DROP CONSTRAINT FK_BFT_Zeit_table<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[Zeit_table]') and<br />
OBJECTPROPERTY(id, N'IsUserTable') = 1)<br />
drop table [dbo].[Zeit_table]<br />
GO<br />
CREATE TABLE [dbo].[Zeit_table] (<br />
[Zeit_id] [varchar] (50) COLLATE Latin1_General_CI_AS<br />
NOT NULL ,<br />
[Z_t] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[Z_t_desc] [varchar] (40) COLLATE Latin1_General_CI_AS<br />
NOT NULL ,<br />
[Z_m] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[Z_m_desc] [varchar] (40) COLLATE Latin1_General_CI_AS<br />
NOT NULL ,<br />
[Z_y] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[Z_y_desc] [varchar] (40) COLLATE Latin1_General_CI_AS<br />
NOT NULL ,<br />
[Z_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[Z_*_desc] [varchar] (40) COLLATE Latin1_General_CI_AS<br />
NOT NULL ,<br />
[level] [bigint] NOT NULL<br />
) ON [PRIMARY]<br />
GO<br />
ALTER TABLE [dbo].[Zeit_table] WITH NOCHECK ADD<br />
CONSTRAINT [PK_Zeit_table] PRIMARY KEY CLUSTERED<br />
(<br />
[Zeit_id]<br />
) ON [PRIMARY]<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[BFT]')<br />
and OBJECTPROPERTY(id, N'IsUserTable') = 1)<br />
drop table [dbo].[BFT]<br />
GO<br />
CREATE TABLE [dbo].[BFT] (<br />
[Agenten_id] [varchar] (50) COLLATE<br />
Latin1_General_CI_AS NOT NULL ,<br />
- 191 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
[Kunden_id] [varchar] (50) COLLATE<br />
Latin1_General_CI_AS NOT NULL ,<br />
[Zeit_id] [varchar] (50) COLLATE Latin1_General_CI_AS<br />
NOT NULL ,<br />
[Umsatz] [MONEY] NOT NULL<br />
) ON [PRIMARY]<br />
GO<br />
ALTER TABLE [dbo].[BFT] WITH NOCHECK ADD<br />
CONSTRAINT [PK_BFT] PRIMARY KEY CLUSTERED<br />
(<br />
[Agenten_id],<br />
[Kunden_id],<br />
[Zeit_id]<br />
) ON [PRIMARY]<br />
GO<br />
ALTER TABLE [dbo].[BFT] ADD<br />
CONSTRAINT [FK_BFT_Agenten_table] FOREIGN KEY<br />
(<br />
[Agenten_id]<br />
) REFERENCES [dbo].[Agenten_table] (<br />
[Agenten_id]<br />
) ON UPDATE CASCADE<br />
GO<br />
ALTER TABLE [dbo].[BFT] ADD<br />
CONSTRAINT [FK_BFT_Kunden_table] FOREIGN KEY<br />
(<br />
[Kunden_id]<br />
) REFERENCES [dbo].[Kunden_table] (<br />
[Kunden_id]<br />
) ON UPDATE CASCADE<br />
GO<br />
ALTER TABLE [dbo].[BFT] ADD<br />
CONSTRAINT [FK_BFT_Zeit_table] FOREIGN KEY<br />
(<br />
[Zeit_id]<br />
) REFERENCES [dbo].[Zeit_table] (<br />
[Zeit_id]<br />
) ON UPDATE CASCADE<br />
GO<br />
- 192 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.8.3.5.3.3 DIE SCRIPTS FÜR DAS FACT CONSTELLATION SCHEMA<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[FK_BFT_Agenten_table]')<br />
and OBJECTPROPERTY(id, N'IsForeignKey') = 1)<br />
ALTER TABLE [dbo].[BFT] DROP CONSTRAINT<br />
FK_BFT_Agenten_table<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[Agenten_table]') and<br />
OBJECTPROPERTY(id, N'IsUserTable') = 1)<br />
drop table [dbo].[Agenten_table]<br />
GO<br />
CREATE TABLE [dbo].[Agenten_table] (<br />
[Agenten_id] [varchar] (50) COLLATE<br />
Latin1_General_CI_AS NOT NULL ,<br />
[A_id] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[A_id_desc] [varchar] (40) COLLATE<br />
Latin1_General_CI_AS NOT NULL ,<br />
[A_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[A_*_desc] [varchar] (40) COLLATE Latin1_General_CI_AS<br />
NOT NULL ,<br />
) ON [PRIMARY]<br />
GO<br />
ALTER TABLE [dbo].[Agenten_table] WITH NOCHECK ADD<br />
CONSTRAINT [PK_Agenten_table] PRIMARY KEY CLUSTERED<br />
(<br />
[Agenten_id]<br />
) ON [PRIMARY]<br />
GO<br />
CREATE INDEX [IX_A_id] ON [dbo].[Agenten_table]([A_id])<br />
ON [PRIMARY]<br />
GO<br />
CREATE INDEX [IX_A_*] ON [dbo].[Agenten_table]([A_*]) ON<br />
[PRIMARY]<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[FK_BFT_Kunden_table]')<br />
and OBJECTPROPERTY(id, N'IsForeignKey') = 1)<br />
ALTER TABLE [dbo].[BFT] DROP CONSTRAINT FK_BFT_Kunden_table<br />
GO<br />
- 193 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[Kunden_table]') and<br />
OBJECTPROPERTY(id, N'IsUserTable') = 1)<br />
drop table [dbo].[Kunden_table]<br />
GO<br />
CREATE TABLE [dbo].[Kunden_table] (<br />
[Kunden_id] [varchar] (50) COLLATE<br />
Latin1_General_CI_AS NOT NULL ,<br />
[K_id] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[K_id_desc] [varchar] (40) COLLATE<br />
Latin1_General_CI_AS NOT NULL ,<br />
[K_gr] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[K_gr_desc] [varchar] (40) COLLATE<br />
Latin1_General_CI_AS NOT NULL ,<br />
[K_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[K_*_desc] [varchar] (40) COLLATE Latin1_General_CI_AS<br />
NOT NULL ,<br />
) ON [PRIMARY]<br />
GO<br />
ALTER TABLE [dbo].[Kunden_table] WITH NOCHECK ADD<br />
CONSTRAINT [PK_Kunden_table] PRIMARY KEY CLUSTERED<br />
(<br />
[Kunden_id]<br />
) ON [PRIMARY]<br />
GO<br />
CREATE INDEX [IX_K_id] ON [dbo].[Kunden_table]([K_id]) ON<br />
[PRIMARY]<br />
GO<br />
CREATE INDEX [IX_K_gr] ON [dbo].[Kunden_table]([K_gr]) ON<br />
[PRIMARY]<br />
GO<br />
CREATE INDEX [IX_K_*] ON [dbo].[Kunden_table]([K_*]) ON<br />
[PRIMARY]<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[FK_BFT_Zeit_table]')<br />
and OBJECTPROPERTY(id, N'IsForeignKey') = 1)<br />
ALTER TABLE [dbo].[BFT] DROP CONSTRAINT FK_BFT_Zeit_table<br />
GO<br />
- 194 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[Zeit_table]') and<br />
OBJECTPROPERTY(id, N'IsUserTable') = 1)<br />
drop table [dbo].[Zeit_table]<br />
GO<br />
CREATE TABLE [dbo].[Zeit_table] (<br />
[Zeit_id] [varchar] (50) COLLATE Latin1_General_CI_AS<br />
NOT NULL ,<br />
[Z_t] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[Z_t_desc] [varchar] (40) COLLATE Latin1_General_CI_AS<br />
NOT NULL ,<br />
[Z_m] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[Z_m_desc] [varchar] (40) COLLATE Latin1_General_CI_AS<br />
NOT NULL ,<br />
[Z_y] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[Z_y_desc] [varchar] (40) COLLATE Latin1_General_CI_AS<br />
NOT NULL ,<br />
[Z_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[Z_*_desc] [varchar] (40) COLLATE Latin1_General_CI_AS<br />
NOT NULL ,<br />
) ON [PRIMARY]<br />
GO<br />
ALTER TABLE [dbo].[Zeit_table] WITH NOCHECK ADD<br />
CONSTRAINT [PK_Zeit_table] PRIMARY KEY CLUSTERED<br />
(<br />
[Zeit_id]<br />
) ON [PRIMARY]<br />
GO<br />
CREATE INDEX [IX_Z_t] ON [dbo].[Zeit_table]([Z_t]) ON<br />
[PRIMARY]<br />
GO<br />
CREATE INDEX [IX_Z_m] ON [dbo].[Zeit_table]([Z_m]) ON<br />
[PRIMARY]<br />
GO<br />
CREATE INDEX [IX_Z_y] ON [dbo].[Zeit_table]([Z_y]) ON<br />
[PRIMARY]<br />
GO<br />
- 195 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
CREATE INDEX [IX_Z_*] ON [dbo].[Zeit_table]([Z_*]) ON<br />
[PRIMARY]<br />
GO<br />
if exists (select * from dbo.sysobjects where id =<br />
object_id(N'[dbo].[BFT]')<br />
and OBJECTPROPERTY(id, N'IsUserTable') = 1)<br />
drop table [dbo].[BFT]<br />
GO<br />
CREATE TABLE [dbo].[BFT] (<br />
[Agenten_id] [varchar] (50) COLLATE<br />
Latin1_General_CI_AS NOT NULL ,<br />
[Kunden_id] [varchar] (50) COLLATE<br />
Latin1_General_CI_AS NOT NULL ,<br />
[Zeit_id] [varchar] (50) COLLATE Latin1_General_CI_AS<br />
NOT NULL ,<br />
[Umsatz] [MONEY] NOT NULL<br />
) ON [PRIMARY]<br />
GO<br />
ALTER TABLE [dbo].[BFT] WITH NOCHECK ADD<br />
CONSTRAINT [PK_BFT] PRIMARY KEY CLUSTERED<br />
(<br />
[Agenten_id],<br />
[Kunden_id],<br />
[Zeit_id]<br />
) ON [PRIMARY]<br />
GO<br />
ALTER TABLE [dbo].[BFT] ADD<br />
CONSTRAINT [FK_BFT_Agenten_table] FOREIGN KEY<br />
(<br />
[Agenten_id]<br />
) REFERENCES [dbo].[Agenten_table] (<br />
[Agenten_id]<br />
) ON UPDATE CASCADE<br />
GO<br />
ALTER TABLE [dbo].[BFT] ADD<br />
CONSTRAINT [FK_BFT_Kunden_table] FOREIGN KEY<br />
(<br />
[Kunden_id]<br />
) REFERENCES [dbo].[Kunden_table] (<br />
[Kunden_id]<br />
) ON UPDATE CASCADE<br />
GO<br />
- 196 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
ALTER TABLE [dbo].[BFT] ADD<br />
CONSTRAINT [FK_BFT_Zeit_table] FOREIGN KEY<br />
(<br />
[Zeit_id]<br />
) REFERENCES [dbo].[Zeit_table] (<br />
[Zeit_id]<br />
) ON UPDATE CASCADE<br />
GO<br />
if exists (select * from dbo.sysobjects where<br />
id = object_id(N'[dbo].[FT A_*K_idZ_m]') and<br />
OBJECTPROPERTY(id, N'IsUserTable') = 1)<br />
drop table [dbo].[FT A_*K_idZ_m]<br />
GO<br />
CREATE TABLE [dbo].[FT A_*K_idZ_m] (<br />
[A_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[K_id] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[Z_m] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[Umsatz] [MONEY] NOT NULL<br />
) ON [PRIMARY]<br />
GO<br />
ALTER TABLE [dbo].[FT A_*K_idZ_m] WITH NOCHECK ADD<br />
CONSTRAINT [PK_FT A_*K_idZ_m] PRIMARY KEY CLUSTERED<br />
(<br />
[A_*] ,<br />
[K_id] ,<br />
[Z_m]<br />
) ON [PRIMARY]<br />
GO<br />
if exists (select * from dbo.sysobjects where<br />
id = object_id(N'[dbo].[FT A_idK_*Z_t]') and<br />
OBJECTPROPERTY(id, N'IsUserTable') = 1)<br />
drop table [dbo].[FT A_idK_*Z_t]<br />
GO<br />
CREATE TABLE [dbo].[FT A_idK_*Z_t] (<br />
[A_id] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
- 197 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
[K_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[Z_t] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[Umsatz] [MONEY] NOT NULL<br />
) ON [PRIMARY]<br />
GO<br />
ALTER TABLE [dbo].[FT A_idK_*Z_t] WITH NOCHECK ADD<br />
CONSTRAINT [PK_FT A_idK_*Z_t] PRIMARY KEY CLUSTERED<br />
(<br />
[A_id] ,<br />
[K_*] ,<br />
[Z_t]<br />
) ON [PRIMARY]<br />
GO<br />
if exists (select * from dbo.sysobjects where<br />
id = object_id(N'[dbo].[FT A_*K_*Z_t]') and<br />
OBJECTPROPERTY(id, N'IsUserTable') = 1)<br />
drop table [dbo].[FT A_*K_*Z_t]<br />
GO<br />
CREATE TABLE [dbo].[FT A_*K_*Z_t] (<br />
[A_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[K_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[Z_t] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[Umsatz] [MONEY] NOT NULL<br />
) ON [PRIMARY]<br />
GO<br />
ALTER TABLE [dbo].[FT A_*K_*Z_t] WITH NOCHECK ADD<br />
CONSTRAINT [PK_FT A_*K_*Z_t] PRIMARY KEY CLUSTERED<br />
(<br />
[A_*] ,<br />
[K_*] ,<br />
[Z_t]<br />
) ON [PRIMARY]<br />
GO<br />
if exists (select * from dbo.sysobjects where<br />
id = object_id(N'[dbo].[FT A_*K_idZ_y]') and<br />
OBJECTPROPERTY(id, N'IsUserTable') = 1)<br />
drop table [dbo].[FT A_*K_idZ_y]<br />
- 198 -
GO<br />
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
CREATE TABLE [dbo].[FT A_*K_idZ_y] (<br />
[A_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[K_id] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[Z_y] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[Umsatz] [MONEY] NOT NULL<br />
) ON [PRIMARY]<br />
GO<br />
ALTER TABLE [dbo].[FT A_*K_idZ_y] WITH NOCHECK ADD<br />
CONSTRAINT [PK_FT A_*K_idZ_y] PRIMARY KEY CLUSTERED<br />
(<br />
[A_*] ,<br />
[K_id] ,<br />
[Z_y]<br />
) ON [PRIMARY]<br />
GO<br />
if exists (select * from dbo.sysobjects where<br />
id = object_id(N'[dbo].[FT A_idK_*Z_m]') and<br />
OBJECTPROPERTY(id, N'IsUserTable') = 1)<br />
drop table [dbo].[FT A_idK_*Z_m]<br />
GO<br />
CREATE TABLE [dbo].[FT A_idK_*Z_m] (<br />
[A_id] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[K_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[Z_m] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[Umsatz] [MONEY] NOT NULL<br />
) ON [PRIMARY]<br />
GO<br />
ALTER TABLE [dbo].[FT A_idK_*Z_m] WITH NOCHECK ADD<br />
CONSTRAINT [PK_FT A_idK_*Z_m] PRIMARY KEY CLUSTERED<br />
(<br />
[A_id] ,<br />
[K_*] ,<br />
[Z_m]<br />
) ON [PRIMARY]<br />
GO<br />
- 199 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if exists (select * from dbo.sysobjects where<br />
id = object_id(N'[dbo].[FT A_idK_grZ_y]') and<br />
OBJECTPROPERTY(id, N'IsUserTable') = 1)<br />
drop table [dbo].[FT A_idK_grZ_y]<br />
GO<br />
CREATE TABLE [dbo].[FT A_idK_grZ_y] (<br />
[A_id] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[K_gr] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[Z_y] [varchar] (12) COLLATE Latin1_General_CI_AS NOT<br />
NULL ,<br />
[Umsatz] [MONEY] NOT NULL<br />
) ON [PRIMARY]<br />
GO<br />
ALTER TABLE [dbo].[FT A_idK_grZ_y] WITH NOCHECK ADD<br />
CONSTRAINT [PK_FT A_idK_grZ_y] PRIMARY KEY CLUSTERED<br />
(<br />
[A_id] ,<br />
[K_gr] ,<br />
[Z_y]<br />
) ON [PRIMARY]<br />
GO<br />
7.9 ERGEBNISSE DER TESTS DER HEURISTIKEN<br />
Um die Funktionalität der Heuristik zu überprüfen, ist es essentiell die richtige Lösung<br />
deterministisch durch einen Algorithmus zu bestimmen. Diese Algorithmen wurden in<br />
den vorhergehenden Kapiteln eingehend behandelt. Dabei wurde sowohl bei der<br />
Permutation als auch bei der Kombination gleiche Ergebnisse erzielt.<br />
7.9.1 PROBLEME BEI TESTEN DER HEURISTIK<br />
Der erste Ansatz war das Testen der Ergebnisse der Heuristik im Vergleich zu den<br />
Ergebnissen der deterministischen Lösung durch die Permutation. Dabei wurden alle<br />
möglichen Sequenzen der zu materialisierenden Cubes unter der Berücksichtigung der<br />
Reihenfolge der Cubes berechnet und die kostenminimale Lösung mit der Heuristik<br />
verglichen. Unglücklicherweise dauert das Berechnen dieser deterministischen Lösung<br />
sehr lange. Das führte sogar bei kleinen APA zu Berechnungszeiten über 1 Jahr.<br />
- 200 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Deshalb wurde in einem zweiten Schritt der Ansatz über die Kombination gewählt.<br />
Dabei wurde die Materialisierungsreihenfolge der Cubes nicht beachtet. Das führte zu<br />
wesentlich weniger Sequenzen, welche in einem zweiten Schritt dann durch den<br />
Algorithmus von Dijkstra, welcher in den Algorithmus GetRightOrder eingebaut wurde,<br />
in die optimale Reihenfolge gebracht. Dadurch konnten akzeptable Berechnungszeiten<br />
von 3 bis 4 Wochen Berechnungszeit für kleine bis mittelgroße APA erreicht werden.<br />
Durch den Einsatz von 4 Rechnern parallel wurden die unten angeführten Ergebnisse<br />
erreicht.<br />
Zusätzlich wurde eine spezielle eine Abbruchbedingung eingeführt. Wenn die<br />
Kombination von z.B. 6 Cubes in jeder möglichen Kombination immer die Spacemax<br />
Bedingung überschritten hat, ist logischerweise auch bei einer Kombination von 7<br />
Cubes das Spacemax Limit überschritten. Deshalb konnte die Berechnung früher<br />
gestoppt werden. Aus diesem Grund wurde auch in den empirischen Probeläufen von<br />
einem sehr geringen verfügbaren Speicherplatz ausgegangen. Nur so konnten die<br />
Berechnungszeiten von bis zu 4 Wochen erreicht werden.<br />
Die Menge der betrachteten Cubes wurden auf die so genannten „Possible Cubes“<br />
eingeschränkt. Dabei würden aus der Gesamtmenge aller Cubes jene Cubes<br />
ausgeklammert, welche jedenfalls keinen positiven Beitrag zur Berechnung der<br />
Required Cubes leisten könnten. So sieht man in Abbildung 79 die mit schwarz<br />
markierten Menge der Possible Cubes. Der beispielhaft aktivierte Cube (4:2): K_gr;<br />
A_*; Z_* bringt dabei keinen zusätzlichen Nutzen für die Materialisierung der Required<br />
Cubes, da keines seiner Derivative ein Required Cube ist. Aus diesem Grund befindet<br />
sich dieser Cube nicht in der Menge der Possible Cubes.<br />
- 201 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 79: Demonstrative Anzeigen der Possible Cubes<br />
7.9.2 GESAMTÜBERSICHT ÜBER DIE ERGEBNISSE<br />
Bezeichnung Kosten Kostenübereinstimmung<br />
Test1 Strukturierte<br />
Zufallskosten<br />
Test2 Strukturierte<br />
Zufallskosten<br />
Test3 Strukturierte<br />
Zufallskosten<br />
Test4 Strukturierte<br />
Zufallskosten<br />
Test5 Strukturierte<br />
Zufallskosten<br />
- 202 -<br />
Spaceleft<br />
Übereinstimmung<br />
Timeleft<br />
Übereinstimmung<br />
100 % 100 % 100 %<br />
100 % 100 % 100 %<br />
100 % 100 % 100 %<br />
100 % 100 % 100 %<br />
100 % 100 % 100 %
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Test6 Strukturierte<br />
Zufallskosten<br />
Test7 Strukturierte<br />
Zufallskosten<br />
Test8 Total Random<br />
Zufallskosten<br />
Test9 Total Random<br />
Zufallskosten<br />
Test10 Total Random<br />
Zufallskosten<br />
Test11 Total Random<br />
Zufallskosten<br />
Test12 Total Random<br />
Zufallskosten<br />
Test13 Mit<br />
Kostenfunktion<br />
Test14 Total Random<br />
Zufallskosten<br />
Test15 Total Random<br />
Zufallskosten<br />
Test16 Mit<br />
Kostenfunktion<br />
Test17 Strukturierte<br />
Zufallskosten<br />
Test18 Mit<br />
Kostenfunktion<br />
100 % 100 % 100 %<br />
100 % 100 % 100 %<br />
100 % 100 % 100 %<br />
100 % 100 % 100 %<br />
100 % 100 % 100 %<br />
100 % 100 % 100 %<br />
100 % 100 % 100 %<br />
100 % 100 % 100 %<br />
100 % 100 % 100 %<br />
100 % 100 % 100 %<br />
100 % 100 % 100 %<br />
100 % 100 % 100 %<br />
4,53 % 10,73 % 26,33 %<br />
- 203 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3 DIE ERGEBNISSE IM DETAIL<br />
7.9.3.1 VORGABEN UND ERGEBNISSE TEST 1<br />
7.9.3.1.1 VORGABEN<br />
Required<br />
Cubes: count<br />
1 3:0 K_*; A_*; G_*; Z_t 10000<br />
2 3:2 K_*; A_id; G_*; Z_m 10000<br />
3 4:2 K_*; A_id; G_*; Z_y 10000<br />
4 2:4 K_gr; A_*; G_*; Z_t 10000<br />
5 1:7 K_gr; A_id; G_b; Z_m 10000<br />
6 2:7 K_gr; A_id; G_b; Z_y 10000<br />
7 3:7 K_gr; A_id; G_b; Z_* 10000<br />
8 1:10 K_id; A_id; G_*; Z_m 10000<br />
7.9.3.1.2 LÖSUNG DER HEURISTIK<br />
- 204 -<br />
Parameter<br />
Spacemax 500000<br />
Timemax 2500000<br />
Zeitkosten 1 bis 100000<br />
Size per Tupel in Bytes: 64<br />
New set on each iteration 4<br />
Max Sets 20
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.1.3 DETERMINISTISCHE LÖSUNG<br />
7.9.3.1.4 VERGLEICH DER ERGEBNISSE<br />
Parameter Heuristik Deterministisch Abweichung<br />
Kosten 971499585 971499585 0,00%<br />
Space left 185952 185952 0,00%<br />
Time left 40415 40415 0,00%<br />
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte<br />
den richtigen Wert im Lösungsweg 1.<br />
7.9.3.2 VORGABEN UND ERGEBNISSE TEST 2<br />
7.9.3.2.1 VORGABEN<br />
Required<br />
Cubes: count<br />
1 4:1 K_*; A_*; G_b; Z_m 1000<br />
2 5:1 K_*; A_*; G_b; Z_y 1000<br />
3 6:1 K_*; A_*; G_b; Z_* 1000<br />
4 3:7 K_gr; A_*; G_b; Z_m 1000<br />
5 4:7 K_gr; A_*; G_b; Z_y 1000<br />
6 2:14 K_id; A_gr; G_*; Z_m 1000<br />
7 3:14 K_id; A_gr; G_*; Z_y 1000<br />
8 4:14 K_id; A_gr; G_*; Z_* 1000<br />
- 205 -<br />
Parameter<br />
Spacemax 100000<br />
Timemax 1500000<br />
Zeitkosten 1 bis 100000<br />
Size per Tupel in Bytes: 64<br />
New set on each iteration 4<br />
Max Sets 20
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.2.2 LÖSUNG DER HEURISTIK<br />
7.9.3.2.3 DETERMINISTISCHE LÖSUNG<br />
- 206 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.2.4 VERGLEICH DER ERGEBNISSE<br />
Parameter Heuristik Deterministisch Abweichung<br />
Kosten 2951750032 2951750032 0,00%<br />
Space left 335040 335040 0,00%<br />
Time left 1399968 1399968 0,00%<br />
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte<br />
den richtigen Wert im Lösungsweg 1.<br />
7.9.3.3 VORGABEN UND ERGEBNISSE TEST 3<br />
7.9.3.3.1 VORGABEN<br />
Required<br />
Cubes: count<br />
1 0:0 K_gr; A_id; G_b; Z_t 1000<br />
2 1:0 K_*; A_id; G_b; Z_t 1000<br />
3 4:0 K_*; A_*; G_*; Z_m 1000<br />
4 5:0 K_*; A_*; G_*; Z_y 1000<br />
5 6:0 K_*; A_*; G_*; Z_* 1000<br />
6 1:10 K_id; A_id; G_*; Z_m 1000<br />
7 2:10 K_id; A_id; G_*; Z_y 1000<br />
8 3:10 K_id; A_id; G_*; Z_* 1000<br />
7.9.3.3.2 LÖSUNG DER HEURISTIK<br />
- 207 -<br />
Parameter<br />
Spacemax 500000<br />
Timemax 1500000<br />
Zeitkosten 1 bis 100000<br />
Size per Tupel in Bytes: 64<br />
New set on each iteration 4<br />
Max Sets 20
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.3.3 DETERMINISTISCHE LÖSUNG<br />
7.9.3.3.4 VERGLEICH DER ERGEBNISSE<br />
Parameter Heuristik Deterministisch Abweichung<br />
Kosten 2950860 2950860 0,00%<br />
Space left 2265920 2265920 0,00%<br />
Time left 1489441 1489441 0,00%<br />
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte<br />
den richtigen Wert im Lösungsweg 2.<br />
- 208 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.4 VORGABEN UND ERGEBNISSE TEST 4<br />
7.9.3.4.1 VORGABEN<br />
Required<br />
Cubes: count<br />
1 0:0 K_gr; A_id; Z_t 10000<br />
2 1:0 K_*; A_id; Z_t 1000<br />
3 2:0 K_*; A_*; Z_t 1000<br />
4 2:1 K_*; A_id; Z_m 1000<br />
5 1:2 K_gr; A_*; Z_t 10000<br />
6 2:2 K_gr; A_*; Z_m 1000<br />
7 3:2 K_gr; A_*; Z_y 1000<br />
8 1:3 K_gr; A_id; Z_m 1000<br />
9 2:3 K_gr; A_id; Z_y 1000<br />
10 0:4 K_id; A_*; Z_t 1000<br />
11 1:4 K_id; A_*; Z_m 1000<br />
12 2:4 K_id; A_*; Z_y 1000<br />
13 0:5 K_id; A_id; Z_m 10000<br />
14 1:5 K_id; A_id; Z_y 10000<br />
15 2:5 K_id; A_id; Z_* 10000<br />
7.9.3.4.2 LÖSUNG DER HEURISTIK<br />
- 209 -<br />
Parameter<br />
Spacemax 500000000<br />
Timemax 1500000<br />
Zeitkosten 1 bis 100000<br />
Size per Tupel in Bytes: 900<br />
New set on each iteration 4<br />
Max Sets 20
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.4.3 DETERMINISTISCHE LÖSUNG<br />
7.9.3.4.4 VERGLEICH DER ERGEBNISSE<br />
Parameter Heuristik Deterministisch Abweichung<br />
Kosten 253922 253922 0,00%<br />
Space left 212414000 212414000 0,00%<br />
Time left 1246080 1246080 0,00%<br />
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte<br />
den richtigen Wert im Lösungsweg 1.<br />
- 210 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.5 VORGABEN UND ERGEBNISSE TEST 5<br />
7.9.3.5.1 VORGABEN<br />
Required<br />
Cubes: count<br />
1 2:0 A_*; K_*; Z_t 10000<br />
2 1:2 A_*; K_id; Z_m 1000<br />
3 2:2 A_*; K_id; Z_y 1000<br />
4 3:2 A_*; K_id; Z_* 1000<br />
5 1:3 A_id; K_*; Z_t 10000<br />
6 2:3 A_id; K_*; Z_m 10000<br />
7 2:4 A_id; K_gr; Z_y 10000<br />
8 1:5 A_id; K_id; Z_y 1<br />
9 2:5 A_id; K_id; Z_* 1<br />
7.9.3.5.2 LÖSUNG DER HEURISTIK<br />
- 211 -<br />
Parameter<br />
Spacemax 500000000<br />
Timemax 1500000<br />
Zeitkosten 1 bis 100000<br />
Size per Tupel in Bytes: 900<br />
New set on each iteration 4<br />
Max Sets 20
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.5.3 DETERMINISTISCHE LÖSUNG<br />
7.9.3.5.4 VERGLEICH DER ERGEBNISSE<br />
Parameter Heuristik Deterministisch Abweichung<br />
Kosten 99578 99578 0,00%<br />
Space left 42400400 42400400 0,00%<br />
Time left 1438916 1438916 0,00%<br />
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte<br />
den richtigen Wert im Lösungsweg 1.<br />
- 212 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.6 VORGABEN UND ERGEBNISSE TEST 6<br />
7.9.3.6.1 VORGABEN<br />
Required<br />
Cubes: count<br />
1 0:0 K_gr; A_id; Z_t 1000<br />
2 1:0 K_*; A_id; Z_t 1000<br />
3 2:0 K_*; A_gr; Z_t 10000<br />
4 1:3 K_gr; A_gr; Z_t 1000<br />
5 2:3 K_gr; A_*; Z_t 1000<br />
6 1:5 K_gr; A_id; Z_m 10000<br />
7 2:5 K_gr; A_id; Z_y 10000<br />
8 3:5 K_gr; A_id; Z_* 10000<br />
9 0:6 K_id; A_gr; Z_t 1<br />
10 1:6 K_id; A_*; Z_t 1000<br />
11 3:6 K_id; A_*; Z_y 10000<br />
12 4:6 K_id; A_*; Z_* 10000<br />
13 2:7 K_id; A_gr; Z_y 1000<br />
7.9.3.6.2 LÖSUNG DER HEURISTIK<br />
- 213 -<br />
Parameter<br />
Spacemax 58000000<br />
Timemax 1500000<br />
Zeitkosten 1 bis 100000<br />
Size per Tupel in Bytes: 900<br />
New set on each iteration 4<br />
Max Sets 20
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.6.3 DETERMINISTISCHE LÖSUNG<br />
7.9.3.6.4 VERGLEICH DER ERGEBNISSE<br />
Parameter Heuristik Deterministisch Abweichung<br />
Kosten 2639020 2639020 0,00%<br />
Space left 1461847 1461847 0,00%<br />
Time left 2576200 2576200 0,00%<br />
Es konnte eine eindeutige Übereinstimmung festgestellt werden. In der<br />
Materialisierungsreihenfolge wurde jedoch eine andere Reihenfolge gewählt. Dies<br />
beeinflusst aber nicht die Kosten. Die Heuristik lieferte den richtigen Wert im<br />
Lösungsweg 1.<br />
- 214 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.7 VORGABEN UND ERGEBNISSE TEST 7<br />
7.9.3.7.1 VORGABEN<br />
Required<br />
Cubes: count<br />
1 3:0 K_*; G_*; Z_t 10000<br />
2 2:3 K_gr; G_*; Z_t 10000<br />
3 3:3 K_gr; G_*; Z_m 10000<br />
4 4:3 K_gr; G_*; Z_y 10000<br />
5 5:3 K_gr; G_*; Z_* 10000<br />
6 1:5 K_gr; G_b; Z_m 1000<br />
7 2:5 K_gr; G_b; Z_y 1000<br />
8 3:5 K_gr; G_b; Z_* 1000<br />
9 1:6 K_id; G_*; Z_t 10000<br />
10 2:6 K_id; G_*; Z_m 10000<br />
11 3:6 K_id; G_*; Z_y 10000<br />
12 4:6 K_id; G_*; Z_* 10000<br />
13 1:8 K_id; G_b; Z_y 10000<br />
7.9.3.7.2 LÖSUNG DER HEURISTIK<br />
- 215 -<br />
Parameter<br />
Spacemax 8000000<br />
Timemax 1500000<br />
Zeitkosten 1 bis 100000<br />
Size per Tupel in Bytes: 120<br />
New set on each iteration 4<br />
Max Sets 20
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.7.3 DETERMINISTISCHE LÖSUNG<br />
7.9.3.7.4 VERGLEICH DER ERGEBNISSE<br />
Parameter Heuristik Deterministisch Abweichung<br />
Kosten 1278025457 1278025457 0,00%<br />
Space left 997040 997040 0,00%<br />
Time left 14824543 14824543 0,00%<br />
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte<br />
den richtigen Wert im Lösungsweg 2.<br />
- 216 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.8 VORGABEN UND ERGEBNISSE TEST 8<br />
7.9.3.8.1 VORGABEN<br />
Required<br />
Cubes: count<br />
1 3:0 K_*; G_*; Z_t 10000<br />
2 2:3 K_gr; G_*; Z_t 10000<br />
3 3:3 K_gr; G_*; Z_m 10000<br />
4 4:3 K_gr; G_*; Z_y 10000<br />
5 5:3 K_gr; G_*; Z_* 10000<br />
6 1:5 K_gr; G_b; Z_m 1000<br />
7 2:5 K_gr; G_b; Z_y 1000<br />
8 3:5 K_gr; G_b; Z_* 1000<br />
9 1:6 K_id; G_*; Z_t 10000<br />
10 2:6 K_id; G_*; Z_m 10000<br />
11 3:6 K_id; G_*; Z_y 10000<br />
12 4:6 K_id; G_*; Z_* 10000<br />
13 1:8 K_id; G_b; Z_y 10000<br />
7.9.3.8.2 LÖSUNG DER HEURISTIK<br />
- 217 -<br />
Parameter<br />
Spacemax 8000000<br />
Timemax 1500000<br />
Zeitkosten 1 bis 100000<br />
Size per Tupel in Bytes: 120<br />
New set on each iteration 4<br />
Max Sets 20
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.8.3 DETERMINISTISCHE LÖSUNG<br />
7.9.3.8.4 VERGLEICH DER ERGEBNISSE<br />
Parameter Heuristik Deterministisch Abweichung<br />
Kosten 29369605 29369605 0,00%<br />
Space left 592760 592760 0,00%<br />
Time left 14920395 14920395 0,00%<br />
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte<br />
den richtigen Wert im Lösungsweg 2.<br />
- 218 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.9 VORGABEN UND ERGEBNISSE TEST 9<br />
7.9.3.9.1 VORGABEN<br />
Required<br />
Cubes: count<br />
1 0:0 K_gr; A_id; Z_t 1000<br />
2 1:0 K_*; A_id; Z_t 1000<br />
3 2:0 K_*; A_gr; Z_t 10000<br />
4 1:3 K_gr; A_gr; Z_t 1000<br />
5 2:3 K_gr; A_*; Z_t 1000<br />
6 1:5 K_gr; A_id; Z_m 10000<br />
7 2:5 K_gr; A_id; Z_y 10000<br />
8 3:5 K_gr; A_id; Z_* 10000<br />
9 0:6 K_id; A_gr; Z_t 1<br />
10 1:6 K_id; A_*; Z_t 1000<br />
11 3:6 K_id; A_*; Z_y 10000<br />
12 4:6 K_id; A_*; Z_* 1000<br />
13 2:7 K_id; A_gr; Z_y 1000<br />
7.9.3.9.2 LÖSUNG DER HEURISTIK<br />
- 219 -<br />
Parameter<br />
Spacemax 58000000<br />
Timemax 1500000<br />
Zeitkosten 1 bis 100000<br />
Size per Tupel in Bytes: 900<br />
New set on each iteration 4<br />
Max Sets 20
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.9.3 DETERMINISTISCHE LÖSUNG<br />
7.9.3.9.4 VERGLEICH DER ERGEBNISSE<br />
Parameter Heuristik Deterministisch Abweichung<br />
Kosten 641966243 641966243 0,00%<br />
Space left 2432200 2432200 0,00%<br />
Time left 1261075 1261075 0,00%<br />
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte<br />
den richtigen Wert im Lösungsweg 2.<br />
- 220 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.10 VORGABEN UND ERGEBNISSE TEST 10<br />
7.9.3.10.1 VORGABEN<br />
Required<br />
Cubes: count<br />
1 2:0 K_*; A_*; G_*; Z_t 1000<br />
2 2:2 K_*; A_id; G_*; Z_m 10000<br />
3 1:3 K_*; A_id; G_b; Z_m 1000<br />
4 2:3 K_*; A_id; G_b; Z_y 1000<br />
5 3:3 K_*; A_id; G_b; Z_* 1000<br />
6 0:4 K_id; A_*; G_b; Z_t 1000<br />
7 1:4 K_id; A_*; G_*; Z_t 10000<br />
8 0:6 K_id; A_id; G_*; Z_t 1<br />
9 1:6 K_id; A_id; G_*; Z_m 1000<br />
10 2:6 K_id; A_id; G_*; Z_y 1000<br />
11 3:6 K_id; A_id; G_*; Z_* 1000<br />
7.9.3.10.2 LÖSUNG DER HEURISTIK<br />
- 221 -<br />
Parameter<br />
Spacemax 200000000<br />
Timemax 1500000<br />
Zeitkosten 1 bis 100000<br />
Size per Tupel in Bytes: 840<br />
New set on each iteration 4<br />
Max Sets 15
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.10.3 DETERMINISTISCHE LÖSUNG<br />
7.9.3.10.4 VERGLEICH DER ERGEBNISSE<br />
Parameter Heuristik Deterministisch Abweichung<br />
Kosten 275596808 275596808 0,00%<br />
Space left 21788960 21788960 0,00%<br />
Time left 1252172 1252172 0,00%<br />
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte<br />
den richtigen Wert im Lösungsweg 1.<br />
- 222 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.11 VORGABEN UND ERGEBNISSE TEST 11<br />
7.9.3.11.1 VORGABEN<br />
Required<br />
Cubes: count<br />
1 3:2 K_*; A_gr; G_*; Z_m 1<br />
2 2:3 K_*; A_gr; G_b; Z_m 10000<br />
3 3:3 K_*; A_gr; G_b; Z_y 1<br />
4 1:4 K_*; A_id; G_*; Z_t 10000<br />
5 2:5 K_*; A_id; G_b; Z_y 10000<br />
6 1:6 K_id; A_*; G_b; Z_t 1000<br />
7 2:6 K_id; A_*; G_*; Z_t 1000<br />
8 2:7 K_id; A_*; G_b; Z_m 10000<br />
9 2:8 K_id; A_gr; G_*; Z_m 10000<br />
10 1:10 K_id; A_id; G_*; Z_m 10000<br />
7.9.3.11.2 LÖSUNG DER HEURISTIK<br />
- 223 -<br />
Parameter<br />
Spacemax 200000000<br />
Timemax 1500000<br />
Zeitkosten 1 bis 100000<br />
Size per Tupel in Bytes: 840<br />
New set on each iteration 4<br />
Max Sets 15
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.11.3 DETERMINISTISCHE LÖSUNG<br />
7.9.3.11.4 VERGLEICH DER ERGEBNISSE<br />
Parameter Heuristik Deterministisch Abweichung<br />
Kosten 447157299 447157299 0,00%<br />
Space left 1328590 1328590 0,00%<br />
Time left 27595880 27595880 0,00%<br />
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte<br />
den richtigen Wert im Lösungsweg 1.<br />
- 224 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.12 VORGABEN UND ERGEBNISSE TEST 12<br />
7.9.3.12.1 VORGABEN<br />
Required<br />
Cubes: count<br />
1 3:0 K_*; G_*; Z_t 10000<br />
2 2:3 K_gr; G_*; Z_t 10000<br />
3 3:3 K_gr; G_*; Z_m 10000<br />
4 4:3 K_gr; G_*; Z_y 10000<br />
5 5:3 K_gr; G_*; Z_* 10000<br />
6 1:5 K_gr; G_b; Z_m 1000<br />
7 2:5 K_gr; G_b; Z_y 1000<br />
8 3:5 K_gr; G_b; Z_* 1000<br />
9 1:6 K_id; G_*; Z_t 10000<br />
10 2:6 K_id; G_*; Z_m 10000<br />
11 3:6 K_id; G_*; Z_y 10000<br />
12 4:6 K_id; G_*; Z_* 10000<br />
13 1:8 K_id; G_b; Z_y 10000<br />
7.9.3.12.2 LÖSUNG DER HEURISTIK<br />
- 225 -<br />
Parameter<br />
Spacemax 8000000<br />
Timemax 15000000<br />
Zeitkosten 1 bis 100000<br />
Size per Tupel in Bytes: 120<br />
New set on each iteration 6<br />
Max Sets 20
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.12.3 DETERMINISTISCHE LÖSUNG<br />
7.9.3.12.4 VERGLEICH DER ERGEBNISSE<br />
Parameter Heuristik Deterministisch Abweichung<br />
Kosten 2873774 2873774 0,00%<br />
Space left 591320 591320 0,00%<br />
Time left 14926226 14926226 0,00%<br />
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte<br />
den richtigen Wert im Lösungsweg 8.<br />
- 226 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.13 VORGABEN UND ERGEBNISSE TEST 13<br />
7.9.3.13.1 VORGABEN<br />
Required<br />
Cubes: count<br />
1 2:0 C_*; A_gr; T_d 10000<br />
2 3:1 C_*; A_gr; T_m 10000<br />
3 2:3 C_gr; A_*; T_d 10000<br />
4 3:3 C_gr; A_*; T_m 10000<br />
5 2:4 C_gr; A_gr; T_m 10000<br />
6 2:5 C_gr; A_id; T_y 10000<br />
7 1:6 C_id; A_*; T_d 10000<br />
7.9.3.13.2 LÖSUNG DER HEURISTIK<br />
- 227 -<br />
Parameter<br />
New set on each iteration 2<br />
Max Sets 50<br />
average time to store a<br />
tupel in time units 2<br />
average time for io in time<br />
units 2<br />
average time for CPU<br />
instructions in time units 0,002<br />
max time 1500000<br />
average time to query in<br />
timeunits 100<br />
average size of a tupel in<br />
bytes 900<br />
max space in bytes 58000000<br />
time weight 75%<br />
query weight 63%
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.13.3 DETERMINISTISCHE LÖSUNG<br />
7.9.3.13.4 VERGLEICH DER ERGEBNISSE<br />
Parameter Heuristik Deterministisch Abweichung<br />
Kosten 1549,136539 1549,136539 0,00%<br />
Space left 2339500 2339500 0,00%<br />
Time left 396,7110032 396,7110032 0,00%<br />
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte<br />
den richtigen Wert im Lösungsweg 29. Damit zeigt dieser Testlauf am deutlichsten die<br />
Grenzen der Heuristik auf. Wäre in den Parameter die Anzahl der Lösungswege auf eine<br />
geringere Anzahl als 29 gesetzt worden, wäre das Ergebnis unrichtig. Deshalb wird im<br />
Test 18 dieses Beispiel nochmals mit neuen Parametern ausgetestet.<br />
- 228 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.14 VORGABEN UND ERGEBNISSE TEST 14<br />
7.9.3.14.1 VORGABEN<br />
Required<br />
Cubes: count<br />
1 0:0 K_gr; A_id; G_b; Z_t 1000<br />
2 1:0 K_*; A_id; G_b; Z_t 1000<br />
3 2:0 K_*; A_*; G_b; Z_t 1000<br />
4 2:3 K_*; A_id; G_b; Z_m 1000<br />
5 3:3 K_*; A_id; G_b; Z_y 1<br />
6 1:4 K_gr; A_*; G_b; Z_t 10000<br />
7 1:6 K_gr; A_id; G_*; Z_t 10000<br />
8 2:6 K_gr; A_id; G_*; Z_m 10000<br />
9 3:6 K_gr; A_id; G_*; Z_y 10000<br />
10 4:6 K_gr; A_id; G_*; Z_* 10000<br />
11 0:8 K_id; A_*; G_b; Z_t 10000<br />
12 1:8 K_id; A_*; G_*; Z_t 10000<br />
13 1:9 K_id; A_*; G_b; Z_m 1000<br />
14 2:9 K_id; A_*; G_b; Z_y 1000<br />
15 3:9 K_id; A_*; G_b; Z_* 1000<br />
16 0:10 K_id; A_id; G_*; Z_t 10000<br />
17 0:11 K_id; A_id; G_b; Z_m 10000<br />
18 1:11 K_id; A_id; G_b; Z_y 10000<br />
19 2:11 K_id; A_id; G_b; Z_* 10000<br />
- 229 -<br />
Parameter<br />
Spacemax 20000000<br />
Timemax 25000000<br />
Zeitkosten 1 bis 100000<br />
Size per Tupel in Bytes: 500<br />
New set on each iteration 4<br />
Max Sets 40
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.14.2 LÖSUNG DER HEURISTIK<br />
- 230 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.14.3 DETERMINISTISCHE LÖSUNG<br />
7.9.3.14.4 VERGLEICH DER ERGEBNISSE<br />
Parameter Heuristik Deterministisch Abweichung<br />
Kosten 1686650247 1686650247 0,00%<br />
Space left 9990000 9990000 0,00%<br />
Time left 24616192 24616192 0,00%<br />
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte<br />
den richtigen Wert im Lösungsweg 1.<br />
- 231 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.15 VORGABEN UND ERGEBNISSE TEST 15<br />
7.9.3.15.1 VORGABEN<br />
Required<br />
Cubes: count<br />
1 1:0 K_*; A_id; Z_t 1<br />
2 3:0 K_*; A_*; Z_t 1000<br />
3 4:1 K_*; A_gr; Z_y 10000<br />
4 3:2 K_*; A_id; Z_y 1000<br />
5 4:3 K_gr; A_*; Z_y 1<br />
6 2:4 K_gr; A_gr; Z_m 1000<br />
7 3:4 K_gr; A_gr; Z_y 1<br />
8 2:6 K_id; A_*; Z_m 10000<br />
9 3:6 K_id; A_*; Z_y 1000<br />
10 1:7 K_id; A_gr; Z_m 1<br />
11 2:8 K_id; A_id; Z_* 1<br />
7.9.3.15.2 LÖSUNG DER HEURISTIK<br />
- 232 -<br />
Parameter<br />
Spacemax 58000000<br />
Timemax 1500000<br />
Zeitkosten 1 bis 100000<br />
Size per Tupel in Bytes: 900<br />
New set on each iteration 6<br />
Max Sets 20
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.15.3 DETERMINISTISCHE LÖSUNG<br />
7.9.3.15.4 VERGLEICH DER ERGEBNISSE<br />
Parameter Heuristik Deterministisch Abweichung<br />
Kosten 32747425 32747425 0,00%<br />
Space left 9287500 9287500 0,00%<br />
Time left 1291048 1291048 0,00%<br />
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte<br />
den richtigen Wert im Lösungsweg 3.<br />
7.9.3.16 VORGABEN UND ERGEBNISSE TEST 16<br />
7.9.3.16.1 VORGABEN<br />
Required<br />
Cubes: count<br />
1 4:3 K_*; G_l; A_gr; Z_t 1<br />
2 3:6 K_*; G_b; A_gr; Z_t 1000<br />
3 4:9 K_*; G_bez; A_*; Z_m 1000<br />
4 2:12 K_gr; G_l; A_id; Z_t 10000<br />
5 3:19 K_gr; G_b; A_gr; Z_m 1<br />
6 2:21 K_gr; G_bez; A_*; Z_t 1000<br />
7 1:24 K_id; G_l; A_id; Z_t 10000<br />
8 2:31 K_id; G_b; A_gr; Z_m 10000<br />
9 0:33 K_id; G_bez; A_gr; Z_t 10000<br />
- 233 -<br />
Parameter<br />
Spacemax 8000000<br />
Timemax 4000000<br />
Zeitkosten 1 bis 100000<br />
Size per Tupel in Bytes: 840<br />
New set on each iteration 4<br />
Max Sets 30
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.16.2 LÖSUNG DER HEURISTIK<br />
- 234 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
- 235 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.16.3 DETERMINISTISCHE LÖSUNG<br />
- 236 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.16.4 VERGLEICH DER ERGEBNISSE<br />
Parameter Heuristik Deterministisch Abweichung<br />
Kosten 6198642 6198642 0,00%<br />
Space left 3934362 3934362 0,00%<br />
Time left 271760 271760 0,00%<br />
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte<br />
den richtigen Wert im Lösungsweg 1.<br />
- 237 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.17 VORGABEN UND ERGEBNISSE TEST 17<br />
7.9.3.17.1 VORGABEN<br />
Required<br />
Cubes: count<br />
1 0:0 K_gr; A_id; G_b; Z_t 10000<br />
2 1:0 K_*; A_id; G_b; Z_t 10000<br />
3 2:0 K_*; A_*; G_b; Z_t 10000<br />
4 2:2 K_*; A_id; G_*; Z_t 10000<br />
5 2:3 K_*; A_id; G_b; Z_m 10000<br />
6 1:4 K_gr; A_*; G_b; Z_t 1<br />
7 2:4 K_gr; A_*; G_*; Z_t 1<br />
8 2:6 K_gr; A_id; G_*; Z_m 10000<br />
9 3:6 K_gr; A_id; G_*; Z_y 10000<br />
10 4:6 K_gr; A_id; G_*; Z_* 10000<br />
11 1:8 K_id; A_*; G_*; Z_t 10000<br />
12 2:8 K_id; A_*; G_*; Z_m 1000<br />
13 3:8 K_id; A_*; G_*; Z_y 1000<br />
14 4:8 K_id; A_*; G_*; Z_* 1000<br />
15 0:11 K_id; A_id; G_b; Z_m 10000<br />
16 1:11 K_id; A_id; G_b; Z_y 10000<br />
17 2:11 K_id; A_id; G_b; Z_* 10000<br />
- 238 -<br />
Parameter<br />
Spacemax 50000000<br />
Timemax 25000000<br />
Zeitkosten 1 bis 100000<br />
Size per Tupel in Bytes: 500<br />
New set on each iteration 4<br />
Max Sets 20
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.17.2 LÖSUNG DER HEURISTIK<br />
- 239 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.17.3 DETERMINISTISCHE LÖSUNG<br />
7.9.3.17.4 VERGLEICH DER ERGEBNISSE<br />
Parameter Heuristik Deterministisch Abweichung<br />
Kosten 1067776407 1067776407 0,00%<br />
Space left 14619500 14619500 0,00%<br />
Time left 24903780 24903780 0,00%<br />
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte<br />
den richtigen Wert im Lösungsweg 1.<br />
- 240 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.18 VORGABEN UND ERGEBNISSE TEST 18<br />
7.9.3.18.1 VORGABEN<br />
Required<br />
Cubes: count<br />
1 2:0 C_*; A_gr; T_d 10000<br />
2 3:1 C_*; A_gr; T_m 10000<br />
3 2:3 C_gr; A_*; T_d 10000<br />
4 3:3 C_gr; A_*; T_m 10000<br />
5 2:4 C_gr; A_gr; T_m 10000<br />
6 2:5 C_gr; A_id; T_y 10000<br />
7 1:6 C_id; A_*; T_d 10000<br />
7.9.3.18.2 LÖSUNG DER HEURISTIK<br />
- 241 -<br />
Parameter<br />
New set on each iteration 2<br />
Max Sets 50<br />
average time to store a<br />
tupel in time units 2<br />
average time for io in time<br />
units 2<br />
average time for CPU<br />
instructions in time units 0,002<br />
max time 1500000<br />
average time to query in<br />
timeunits 100<br />
average size of a tupel in<br />
bytes 900<br />
max space in bytes 58000000<br />
time weight 75%<br />
query weight 63%
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
7.9.3.18.3 DETERMINISTISCHE LÖSUNG<br />
7.9.3.18.4 VERGLEICH DER ERGEBNISSE<br />
Parameter Heuristik Deterministisch Abweichung<br />
Kosten 1619,256708 1549,136539 -4,53%<br />
Space left 2088400 2339500 10,73%<br />
Time left 1016362,41 804498,9363 -26,33%<br />
Es konnte keine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte<br />
den Wert im Lösungsweg 4. Damit zeigt dieser Testlauf am deutlichsten die Grenzen<br />
der Heuristik auf. Wäre in den Parameter die Anzahl der Lösungswege auf eine größere<br />
Anzahl als 29 gesetzt worden, wäre das Ergebnis richtig.<br />
8 CONCLUSIO<br />
Das Ziel und die Vision, die am Beginn dieser Arbeit stand, war es eine Heuristik zu<br />
entwickeln, welche die Auswahl der zu materialisieren Cubes treffen kann, diese zu<br />
Testen, die Test zu analysieren und zu bewerten. Deshalb war die Arbeit eine von sehr<br />
viel praktischer Programmiertätigkeit geprägte. Zusätzlich wurden jedoch in den<br />
Kapiteln 1 bis 6 die methodischen und inhaltsbezogenen Grundlagen zum Abhandeln<br />
der Arbeit gelegt. Dabei bin ich im Kapitel 1 speziell auf die Ziele, welche diese Arbeit<br />
begründen, eingegangen. Im Kapitel 2 wurde dann auf die Datenmodellierung<br />
eingegangen, da mit dem Aggregation Path Array eine Modellierungsmethode für<br />
- 242 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Datawarehousesysteme als Werkzeug benutzt wird. Diese Modellierungsmethode wurde<br />
im Kapitel 6 im Detail behandelt. Im Kapitel 3 wurde dann speziell auf Datenbanken<br />
und SQL eingegangen, da im Prinzip ein Datawarehouse eine große Datenbank<br />
darstellt. Kapitel 4 beschäftigt sich kurz mit ERP-Systemen im Allgemeinen, wobei ich<br />
hier nicht in die Tiefe gegangen bin, da es für unsere Fragestellung grundsätzlich<br />
unerheblich ist, woher die Daten stammen. Allerdings wird die von mir entwickelte<br />
Software im Lehrbetrieb der Universität in Kombination mit einem ERP System<br />
eingesetzt werden. Kapitel 5 geht im Speziellen auf das Datawarehouse ein. Das Kapitel<br />
7 beschäftigt sich dann auf den eigentlichen Forschungsgegenstand. Dabei wird meine<br />
Heuristik präsentiert, beschrieben und begründet. So wird insbesondere der Algorithmus<br />
von Dijkstra verwendet, um eine Materialisierungsreihenfolge der Cubes zu finden. Zur<br />
Bestimmung der deterministischen Lösung wurde ein Ansatz über die Permutation und<br />
ein Ansatz über die Kombination in Verbindung mit Dijkstra vorgestellt. Beide liefern<br />
das gleiche Ergebnis. Dabei hat die Kombination bei kleinen APAs<br />
Geschwindigkeitsvorteile und die Permutation bei großen. Das Bestimmen der<br />
deterministischen Lösungen hat sehr viel Rechenzeit in Anspruch genommen (ca 3 bis 4<br />
Wochen pro Ergebnis). Durch den Einsatz von vier unterschiedlichen Rechnern wurde<br />
versucht dieses Problem in den Griff zu bekommen und abschließend können nun<br />
immerhin 18 Lösungen präsentiert werden. Die Ergebnisse, welche in Kapitel 7.9.2<br />
aufgelistet sind brachten außergewöhnlich gute Ergebnisse. So konnte fast immer eine<br />
100 % Übereinstimmung der heuristischen und deterministischen Lösung erreicht<br />
werden. Allerdings konnte im Test 18 aufgezeigt werden, dass die Genauigkeit der<br />
Heuristik von der Anzahl der Testläufe abhängt. Somit kann gezeigt werden, dass die<br />
Genauigkeit der heuristischen Lösung durch den Benutzer einstellbar ist. Dabei besteht<br />
ein Konflikt zwischen Berechnungszeit und Genauigkeit. Ausserdem muss beachtet<br />
werden, dass nur kleine APAs mit relativ geringen Speicher- bzw. Zeitlimits getestet<br />
wurden, um die Rechenzeit für die deterministische Lösung gering zu halten. Deshalb<br />
wäre es interessant zusätzliche Testläufe in eine zukünftige Forschungsarbeit<br />
einzubauen. Diesbezügliche Vorgespräche wurden mit Professor Prosser bereits geführt.<br />
Der Zeitgewinn durch den Einsatz der Heuristik, welche bei den vorgestellten APAs<br />
zwischen 2 und 30 Sekunden Berechnungszeit, im Vergleich zu 3 bis 4 Wochen<br />
Berechnungszeit der deterministischen Lösung, benötigt, ist enorm. Das macht die<br />
Heuristik für namhafte Softwarefirmen interessant. Deshalb wäre es in einem nächsten<br />
Schritt sinnvoll die Heuristik mit dem Produkt eines Datenbankherstellers zu<br />
kombinieren. Dabei könnte auch unmittelbar auf die Kostenfunktionen des Query<br />
Optimizers des Herstellers zugegriffen werden. Dies wäre nach meiner Ansicht für den<br />
praktischen Einsatz der Software jedenfalls notwendig.<br />
- 243 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Zusätzlich zur rein wissenschaftlichen Arbeit wurde eine Softwareanwendung<br />
entwickelt, welche didaktisch eingesetzt werden soll. Diese Anwendungen möchte ich<br />
als höchste gelungen bezeichnen, da sie optimal für die Bedürfnisse der Studenten<br />
maßgeschneidert wurde. Damit kann jeder Student in praktischer Tätigkeit die<br />
Modellierung und die Entwicklung eines Datawarehouse vollziehen. Der Sourcecode<br />
sowie die Hilfedatei im HTML Format befinden sich im Anhang und stellten einen<br />
maßgeblichen Arbeitszeitanteil an dieser Arbeit dar.<br />
9 LITERATUR<br />
Achs, T. L., (2002), Erstellung eines Java-basierten Programms zur Implementierung<br />
des Aggregationspfadarrays – Diplomarbeit an der Wirtschaftsuniversität Wien<br />
Anahory, Sam, Murray, Dennis, (1997), Data Warehouse - Planung, Implementierung<br />
und Administration, Addision-Wesley-Logman, Bonn; Reading, Massachusetts u.a..<br />
Archilles, A., (2000), SQL – Standardisierte Datenbanksprache vom PC bis zum<br />
Mainframe, 7. Aufl., Oldenbourg Wissenschaftsverlag GmbH, München<br />
Baldi, St., (1999), Grundlagen der Wirtschaftsinformatik, 2. Aufl., Oldenbourg Verlag,<br />
München<br />
Barth, M., Karl, G., (2002), MySQL, DATA BECKER GmbH & Co. KG, Düsseldorf<br />
Codd, E.F., (1970), A Relational Model of Data for Large Shared Data Banks“, CACM<br />
Colby, L., Kawaguchi, A., Lieuwen, F., Mumick, I., Ross, K., (1997), Supporting<br />
Multiple View Maintenance Policies, In: Joan Peckham (Ed.): SIGMOD 1997,<br />
Proceedings ACM SIGMOD International Conference on Management of Data, May<br />
13-15, 1997, Tucson, Arizona, USA. ACM Press 1997, SIGMOD Record 26(2), June<br />
1997, S. 405 - 416<br />
Connolly, T., Begg, C., Strachan, A., (2002), Datenbanksysteme, Addision-Wesely<br />
Verlag, ein Imprint der Peason Education Deutschland GmbH, München<br />
Cordts, S., (2002), Datenbankkonzepte in der Praxis, Addison-Wesley Verlag ein<br />
Imprint der Pearson Education Deutschland GmbH, München<br />
Crawley, P., Dilworth, R.P. (1973), Algebraic theory of lattice, Englewood Cliffs, New<br />
Jersey<br />
- 244 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Dippold, R., Meier, A., Ringgenberg, A., Schnider, W., Schwinn, K.,<br />
Unternehmensweites Datenmanagement, (2001), 3. Aufl., Friedr. Vieweg & Sohn<br />
Verlagsgesellschaft mbH, Braunschweig/Wiesbaden<br />
Dunemann, O., (2002), Anfrageoptimierung für OLAP-Anwendungen in virtuellen Data<br />
Warehouses, Tenea Verlag für Medien, Berlin<br />
Džeroski, S., Lavrač, N., (2001), Relational Data Mining, Springer Verlag, Berlin et al.<br />
Ehrenberg, D., Heine, P., (1998), Konzept zur Datenintegration für Management<br />
Support Systeme auf der Basis uniformer Datenstrukturen, In: Wirtschaftsinformation<br />
40. (1998), 6, S. 503-512<br />
Falkowksi, B., (2002), Business Computing – Grundlagen und Standardsoftware,<br />
Springer Verlag, Berlin u.a.<br />
Fischer, J., Herold, W., Dangelmaier, W., Nastansky, L.; Suhl, L.; (2000), Bausteine der<br />
Wirtschaftsinformatik, 2. Aufl., Erich Schmidt Verlag GmbH & Co., Berlin<br />
Fritz, M., (1997), Data Warehouse Technologie, In: Datenbank-Management, Interest-<br />
Verlag, Augsburg<br />
Gabriel, R., Röhrs, H.P., (2003), Gestaltung und Einsatz von Datenbanksystemen,<br />
Springer Verlag, Berlin et al.<br />
Geppert, A., (2002), Objektrelationale und objektorientierte Datenbankkonzepte und –<br />
systeme, dpunkt.verlag GmbH, Heidelberg<br />
Golfarelli, M., Maio, D., Rizzi, S. (1998), Conceptual Design on data warehouses from<br />
E/R Schemas; in: Proceeding of Hawaii International Conference On System Sciences,<br />
January 6-9, 1998, Kona, Hawaii, ftp://ftp-db.deis.unibo.it/pub/hicss98.pdf (22.02.2001)<br />
Goos, G., (2000), Vorlesungen über Informatik – Band 1, 3. Aufl., Springer-Verlag<br />
Berlin, u.a.<br />
Günther, H. O., Tempelmeier, H. (1997), Produktion und Logistik, 3. Aufl., Springer-<br />
Verlag, Berlin u.a.<br />
Hansen, H.R., (1996), Wirtschaftsinformatik I; 7. Auflage, Lucius & Lucius, Stuttgart<br />
Härder, T., Rahm, E., (2001), Datenbanksysteme, 2. Aufl., Springer-Verlag Berlin u.a.<br />
- 245 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Harinarayan, V., Rajaraman, A., Ullmann, J.D., (1996), Implementing Data Cubes<br />
Efficiently, In Proceedings of ACM SIGMOD Conference, Montreal, Canada, June<br />
1996<br />
Hartmut, E., (2000), Grundlagen und Konzepte der Informatik, 2. Aufl., Friedr. Vieweg<br />
& Sohn Verlagsgesellschaft mbH, Braunschweig, Wiesbaden<br />
Heinrich, L. J., (2002) Wirtschaftsinformatik, 2. Aufl., Oldenbourg Wissenschaftsverlag<br />
GmbH, München<br />
Houlette, F., (2002), SQL- IT Tutorial, mitp-Verlag, Bonn<br />
Janko, W., H., (1998), Informationswirtschaft 1, 2. Aufl., Springer-Verlag, Berlin u.a.<br />
Jianzhong, L., Doron, R., Jaideep, S., (1999), Aggregation Alogrithms for Very Large<br />
Compressed Data Warehouses, In: Proceedings of the 25 th Very Large Database<br />
Conference, Edinburgh, Scotland, 1999, Morgan Kaufmann Publishers, Orlando<br />
Kaiser, A. (2000), Skriptum zur Lehrveranstaltung Management und<br />
Informationssysteme, Institut für Informationswirtschaft, http://exai3.wuwien.ac.at/~kaiser/mis/<br />
(20.11.2000)<br />
Kemper, A., Eickler, A., (1996), Datenbanksysteme – Eine Einführung, Oldenbourg<br />
Verlag, München, Wien<br />
Kemper, A., Eickler, A., (1999), Datenbanksysteme, 3. Aufl., Oldenbourg Verlag,<br />
München<br />
Kleinschmidt, P., Rank, C., (2002), Relationale Datenbanksysteme – Eine praktische<br />
Einführung, 2. Aufl., Springer Verlag Berlin et al.<br />
Labio, W. J., Zhuge, Y., Wiener, J.L., Gupta, H., Garcia-Molina, H., Widom, J., (1997),<br />
The WHIPS Prototype for Data Warehous Creation and Maintenance, Joan Peckham<br />
(Ed.): SIGMOD 1997, Proceedings ACM SIGMOD International Conference on<br />
Management of Data, May 13-15, 1997, Tucson, Arizona, USA. ACM Press 1997,<br />
SIGMOD Record 26(2), June 1997, S. 557 -559<br />
Lusti, M. (1999), Data Warehousing und Data Mining, 1. Aufl., Springer-Verlag, Berlin<br />
u.a.<br />
Marsch, J., Fritze, J., (1999), Erfolgreiche Datenbankanwendung mit SQL, 5. Aufl.,<br />
- 246 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Friedr. Vieweg & Sohn Verlagsgesellschaft mbH, Braunschweig, Wiesbaden<br />
Martin, W. (1998), Data Warehousing, 1. Aufl., Internat. Thomson Publ., Bonn u.a.<br />
Meier, A., (2001), Relationale Datenbanken, 4. Auflage, Springer-Verlag, Berlin u.a.<br />
Mertens, P., Wieczorrek, H. W., (2000), Data X Strategien - Data Warehouse, Data<br />
Mining und operationale Systeme für die Praxis, Springer-Verlag, Berlin u.a.<br />
Morcinek, P., (2002), SQL, Data Becker GmbH & Co. KG, Düsseldorf<br />
Müller-Angstenberger, J. W., (1994), Die Arbeitsweise des DB2-Optimizers, In:<br />
Datenbank-Management, Interest-Verlag, Augsburg<br />
Mumick, I., Quass, D., Mumick, B., (1997), Maintenance of Data Cubes and Summary<br />
Tables in a Warehouse,In: Joan Peckham (Ed.): SIGMOD 1997, Proceedings ACM<br />
SIGMOD International Conference on Management of Data, May 13-15, 1997, Tucson,<br />
Arizona, USA. ACM Press 1997, SIGMOD Record 26(2), June 1997, S. 100 - 111<br />
Panny, W., Taudes, A., (2000), Einführung in den Sprachkern von SQL-99, Springer-<br />
Verlag, Berlin u.a.<br />
Pernul, G., Unland, R., (2001), Datenbanken im Unternehmen, Oldenbourg<br />
Wissenschaftsverlag GmbH, München, Wien<br />
Prosser, A., Ossimitz, M. L., (2000a), Analytical Logistics Information System SAP<br />
BW – Teaching Material for the Department of Production Management ), WS 00/01,<br />
Prosser, A., Ossimitz, M. L., (2000b), Eine Methode zur konzeptionellen Modellierung<br />
multidimensionaler Datenstrukturen im Data Warehouse (Handout)<br />
Prosser, A., Ossimitz, M. L., (2001), Data Warehouse Management – Using SAP BW,<br />
Facultas Verlags- und Buchhandels AG, Wien<br />
Prosser, A., Ossimitz, M. L., (2002), Data Warehouse Management – Teaching Material<br />
for the Department of Production Management ), WS 02/03,<br />
Rautenstrauch, C., Schulze, T., (2003), Informatik für Wirtschaftswissenschaftler und<br />
Wirtschaftsinformatiker, Springer-Verlag Berlin u.a.<br />
Redaktion Toolbox, (2002), Datenbanken mit Delphi, C&L Computer und<br />
Literaturverlag, Böblingen<br />
- 247 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Reß, H., Viebeck, G., (2000), Datenstrukturen und Algorithmen, Carl Hanser Verlag,<br />
München, Wien<br />
Riordan, R. M., (2000), Microsoft SQL Server 2000 Programmierung, Microsoft Press<br />
Deutschland, Unterschleißheim<br />
Saake, G., Sattler, K., (2002), Algorithmen & Datenstrukturen – Eine Einführung mit<br />
Java, dpunkt.verlag GmbH, Heidelberg<br />
Schicker, E., (1999), Datenbanken und SQL, 2. Aufl., B.G. Teuber, Stuttgart, Leibzig<br />
Schneider, U., Werner, D., (2000), Taschenbuch der Informatik, 3. Aufl., Carl Hanser<br />
Verlag, München, Wien<br />
Sedgewick, R., (2002), Algorithmen, 2. Aufl., Addison-Wesley, München et al.<br />
Seemann, A., Schmalzridt, B., Lehmann, P., (2001), SAP Business Information<br />
Warehouse, Galileo Press, Bonn<br />
Shaw, M.; Blanning, R., Strader, T., Whinston, A., (2000), Handbook on electronic<br />
commerce, Springer-Verlag Berlin u.a.<br />
Stock, W., (2000), Informationswirtschaft, Oldenburg Wissenschaftsverlag GmbH,<br />
München<br />
Taylor, G. A., (2001), SQL für Dummies, 2. Aufl., mitp-Verlag ein Geschäftsbereich<br />
der verlag moderne industrie Buch AG & Co. KG, Landsberg<br />
Vossen, G., (2000), Datenmodelle, Datenbanksprachen und<br />
Datenbankmanagementsysteme, 4. Aufl., Oldenbourg Verlag, München, Wien<br />
Widenius, M., Axmark, D., (2002), MySQL- Das offizielle Handbuch, Die Deutsche<br />
Bibliothek<br />
Witt, K., (2001), Algebraische Grundlagen der Informatik – Zahlen –Strukturen –<br />
Codierung – Verschlüsselung, Friedr. Vieweg & Sohn Verlagsgesellschaft mbH,<br />
Braunschweig / Wiesbaden<br />
Witten, I.H., Eibe, F., (2000), Data mining: practical machine learning tools and<br />
techniques with Java implementations, Morgan Kaufmann Publishers, San Francisco<br />
Yang, J., Karlapalem, K., Li, Q., (1997), Algorithms for Materialized View Design in<br />
- 248 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Data Warehousing Environment, In: Proceedings of the 23rd VLDB Conference<br />
Athens, Greece ftp://www.vldb.org/conf/1997/P136.PDF (22.02.2001)<br />
- 249 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
10 ABBILDUNGSVERZEICHNIS<br />
Abbildung 1: Symbol für Entitätstyp.............................................................................. 18<br />
Abbildung 2: Super- und Subentitätstypen mit „is a“ Operator [Quelle:<br />
Rautenstrauch/Schulze (2003) S. 237].................................................................... 19<br />
Abbildung 3: Entitätsmenge mit Attributen.................................................................... 19<br />
Abbildung 4: Einfaches Symbol eines Beziehungstyps für einfache Darstellbarkeit .... 20<br />
Abbildung 5: Formal richtiges Beziehungssymbol der ER-Modell Konvention ........... 20<br />
Abbildung 6: 1:1 Beziehung zwischen Kunde und Hauptwohnsitz ............................... 21<br />
Abbildung 7: 1:n Beziehung zwischen Abteilung und Mitarbeiter ................................ 22<br />
Abbildung 8: m:n Beziehung zwischen Mitarbeiter und Projekt ................................... 22<br />
Abbildung 9: Rekursiver Beziehungstyp [Quelle: Rautenstrauch/Schulze (2003) S. 237]<br />
................................................................................................................................23<br />
Abbildung 10: Firmenhierarchie..................................................................................... 24<br />
Abbildung 11: Beispielhafte Umsetzung einer 1:1 Beziehung in das Realtionenmodell<br />
in der vereinfachten Darstellung der Beziehung [Quelle: Baldi (1999), S. 84 ]..... 29<br />
Abbildung 12: Beispielhafte Umsetzung einer 1:n Beziehung in das Relationenmodell<br />
in der vereinfachten Darstellung der Beziehung [Quelle: Baldi (1999), S. 84]...... 30<br />
Abbildung 13: Beispielhafte Umsetzung einer m:n Beziehung in das Relationenmodell<br />
in der vereinfachten Darstellung der Beziehung [Quelle: Baldi (1999), S. 84 ]..... 31<br />
Abbildung 14: Relationale Datenstruktur [in Anlehnung: Panny/Taudes (2000) S. 23] 37<br />
Abbildung 15: Die Architektur eine Data Warehouse [Quelle: in Anlehnung an<br />
Posser/Ossimitz (2001) S. 26] ................................................................................ 49<br />
Abbildung 16: Die Basisarchitektur des WHIPS Systems [Quelle: Labio et al. (1997) S.<br />
557] ......................................................................................................................... 56<br />
Abbildung 17: Die WHIPS System Architektur für Warehouse Maintenance [Quelle:<br />
Labio et at (1997) S. 558] ....................................................................................... 57<br />
Abbildung 18: Das Modellsystem [Quelle: Kaiser (2000)]............................................ 67<br />
Abbildung 19: Phasen der Modellierung [Quelle: Kaiser (2000)] ................................. 68<br />
Abbildung 20: Einfache Hierarchie am Beispiel eines Kunden ..................................... 69<br />
Abbildung 21: Darstellung eines Würfels (cube) mit den Dimensionen Zeit, Artikel und<br />
Kunden [ in Anlehnung: Prosser/Ossimitz (2000), S. 18] ...................................... 70<br />
- 250 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 22: Selektion der Daten durch das Slice-Verfahren [Quelle: Schinzer et al.<br />
(1997), S. 40] .......................................................................................................... 71<br />
Abbildung 23: Die Navigation durch die Navigationsebenen [in Anlehnung: Prosser,<br />
Ossimitz (2000 a), S. 24 ] ....................................................................................... 72<br />
Abbildung 24: Einfaches Modell eines dreidimensionalen „Fact-Schema“ [in<br />
Anlehnung: Prosser, Ossimitz, (2000 a), S. 29]...................................................... 73<br />
Abbildung 25: Attributsbaum vor Pruning und Grafting [in Anlehnung: Prosser,<br />
Ossimitz, (2000 a), S. 33] ....................................................................................... 74<br />
Abbildung 26: Attributsbaum nach Pruning und Grafting [in Anlehnung: Prosser,<br />
Ossimitz, (2000 a), S. 34] ....................................................................................... 74<br />
Abbildung 27: Gitter [in Anlehnung: Prosser, Ossimitz (2000 a), S. 40]....................... 75<br />
Abbildung 28: Star-Schema mit „Fact-Table“ (gelb) und vier Dimension-Tables [In<br />
Anlehnung: Prosser, Ossimitz (2000 a), S. 51]....................................................... 77<br />
Abbildung 29: Das klassische Star-Schema [In Anlehnung: Prosser/Ossimitz (2000a ) S.<br />
51] ........................................................................................................................... 78<br />
Abbildung 30: Das Fact Constellation-Schema [Quelle: Prosser/Ossimitz (2001) S. 76]<br />
................................................................................................................................79<br />
Abbildung 31: Snowflake-Schema mit Attribut-Tables [in Anlehnung: Prosser,<br />
Ossimitz (2000a), S. 62] ......................................................................................... 80<br />
Abbildung 32: Galaxy-Schema und Multitube-Architektur [Quelle:<br />
Rautenstrauch/Schulze (2003) S. 334].................................................................... 81<br />
Abbildung 33: Das Unimu-Schema [Quelle: Ehrenberg/Heine (1998) S. 507] ............. 82<br />
Abbildung 34: Darstellung des APA des Praxisbeispiels in Kurznotation (links) und mit<br />
Attributsnamen (rechts) nicht redundanzfrei [in Anlehnung: Prosser, Ossimitz,<br />
(2000 a), S. 43] ...................................................................................................... 83<br />
Abbildung 35: Darstellung des APA des Praxisbeispiels in Kurznotation (links) und mit<br />
Attributsnamen (rechts) redundanzfreie Menge farblich markiert [in Anlehnung:<br />
Prosser, Ossimitz (2000 a), S. 43] ......................................................................... 86<br />
Abbildung 36: Darstellung der interessanten Würfel [in Anlehnung: Prosser, Ossimitz<br />
(2000 b), S. 17 ] ...................................................................................................... 87<br />
Abbildung 37: Anzeigebeispiel der Derivative (Bereich x) des Würfels x [in Anlehnung:<br />
Prosser, Ossimitz (2000 b), S. 17] .......................................................................... 89<br />
- 251 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 38: Anzeigebeispiel der Derivate (Bereich y) des Würfels y [in Anlehnung:<br />
Prosser, Ossimitz (2000 b), S. 17] .......................................................................... 89<br />
Abbildung 39: Anzeigebeispiel der Derivate (Bereich x + y) der Würfels x und y [in<br />
Anlehnung: Prosser, Ossimitz (2000 b), S. 17] ...................................................... 90<br />
Abbildung 40: Abgrenzung der Phasen der Betrachtung ............................................... 93<br />
Abbildung 41: Graph mit zwei Knoten........................................................................... 95<br />
Abbildung 42: Bewerteter Graph [Quelle: Reß/Viebock (2000) S. 404] ....................... 98<br />
Abbildung 43: Darstellung der Knoten und Kanten ..................................................... 107<br />
Abbildung 44: Funktionsweise eines Kostenmodells [Quelle: Kemper/Eickler (1996) S.<br />
212] ....................................................................................................................... 109<br />
Abbildung 45: Beispielhafte Arbeitsabfolge im G-Algorithmus [Quelle: Jianzhong<br />
(1999) S. 654] ....................................................................................................... 114<br />
Abbildung 46: Schematische Aufstellung der Würfel und Kostenfunktionen ............. 122<br />
Abbildung 47: Dimensionen und Hierarchien des DemoAPA..................................... 135<br />
Abbildung 48: DemoAPA mit Lösung ......................................................................... 135<br />
Abbildung 49: Schritt 1 der Heuristik nach Thomas ACHS ........................................ 136<br />
Abbildung 50: Schritt 2 der Heuristik nach Thomas ACHS ........................................ 137<br />
Abbildung 51: Schritt 3 der Heuristik nach Thomas ACHS ........................................ 137<br />
Abbildung 52: Schritt 4 der Heuristik nach Thomas ACHS ........................................ 138<br />
Abbildung 53: Schritt 5 der Heuristik nach Thomas ACHS ........................................ 138<br />
Abbildung 54: Schritt 6 der Heuristik nach Thomas ACHS ........................................ 139<br />
Abbildung 55: Schritt 7 der Heuristik nach Thomas ACHS ........................................ 139<br />
Abbildung 56: Schritt 8 der Heuristik nach Thomas ACHS ........................................ 140<br />
Abbildung 57: Schritt 9 der Heuristik nach Thomas ACHS ........................................ 140<br />
Abbildung 58: Schritt 10 der Heuristik nach Thomas ACHS ...................................... 141<br />
Abbildung 59: Schritt 11 der Heuristik nach Thomas ACHS ...................................... 141<br />
Abbildung 60: Schritt 12 der Heuristik nach Thomas ACHS ...................................... 142<br />
Abbildung 61: Schritt 13 der Heuristik nach Thomas ACHS ...................................... 142<br />
Abbildung 62: Schritt 14 der Heuristik nach Thomas ACHS ...................................... 143<br />
Abbildung 63: Schritt 15 der Heuristik nach Thomas ACHS ...................................... 143<br />
- 252 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Abbildung 64: Schritt 95 der Heuristik nach Thomas ACHS ...................................... 144<br />
Abbildung 65: Schritt 96 der Heuristik nach Thomas ACHS ...................................... 144<br />
Abbildung 66: Schritt 97 der Heuristik nach Thomas ACHS ...................................... 145<br />
Abbildung 67: Schritt 98 der Heuristik nach Thomas ACHS ...................................... 146<br />
Abbildung 68: Schritt 99 der Heuristik nach Thomas ACHS ...................................... 146<br />
Abbildung 69: Das Hauptmenu des APA Programmes................................................ 166<br />
Abbildung 70: Der APA Input Screen.......................................................................... 167<br />
Abbildung 71: Die Präsentationsmaske des APA Grid ................................................ 168<br />
Abbildung 72: Die Auswahlmaske der Required Cubes .............................................. 169<br />
Abbildung 73: ER-Diagramm für die APA Datenbank................................................ 171<br />
Abbildung 74: Ableitung des APA Relationenmodells aus dem APA ER-Modell...... 175<br />
Abbildung 75: Der Aufbau eines Star Schemas als Basis der CREATE TABLE<br />
Anweisungen ........................................................................................................ 185<br />
Abbildung 76: Beispielhafte Auflistung der Dimension Tables und der Fact Tables beim<br />
Fact Constellation-Schema ................................................................................... 187<br />
Abbildung 77: Input Screen des Demo APA................................................................ 188<br />
Abbildung 78: APA Grid Screen des Demo APA........................................................ 189<br />
Abbildung 79: Demonstrative Anzeigen der Possible Cubes....................................... 202<br />
- 253 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
11 TABELLENVERZEICHNIS<br />
Tabelle 1: Kombinationen von Grad und Ausprägung................................................... 21<br />
Tabelle 2: Gegenüberstellung von relationalen und SQL-Ausdrücken [Quelle:<br />
Pernul/Unland (2001) S. 263]................................................................................. 35<br />
Tabelle 3: Vergleich operative Daten und Data Warehouse [in Anlehnung: Connolly et<br />
al. (2002) S. 910; Prosser, Ossimitz (2000 a), S. 11].............................................. 54<br />
Tabelle 4: Änderungen der Aggregate nach Funktionen [Quelle: Mumick et al. (1997)<br />
S.105]...................................................................................................................... 59<br />
Tabelle 5: Informationsflüsse im Data Warehouse [Quelle: Connolly et al. (2002) S.<br />
918ff] ...................................................................................................................... 60<br />
Tabelle 6: Operatoren und Zahlentypen [in Anlehnung: Prosser, Ossimitz (2000 a), S.<br />
20] ........................................................................................................................... 70<br />
Tabelle 7: Berechnung der kürzesten Wege von einem Knoten in einem Graph zu allen<br />
anderen [Quelle: Reß/Viebeck (2000) S. 405]........................................................ 99<br />
Tabelle 8: Berechnung der kürzesten Wege für einen azyklischen Graphen [Quelle:<br />
Reß/Viebeck (2000) S. 408] ................................................................................. 104<br />
Tabelle 9: Entwicklung der Query Response Time im Verhältnis zur Size [Quelle:<br />
Harinarayan et al. (1996) S. 11]............................................................................ 111<br />
Tabelle 10: : Beschreibung der Tables der APA Datenbank........................................ 174<br />
Tabelle 11: Beispielhafter BFT für die Anwendung .................................................... 185<br />
Tabelle 12: Beispielhafter Customer-Dimensionstable für die Anwendung ................ 186<br />
Tabelle 13: Beispielhafter Items-Dimensionstable für die Anwendung....................... 186<br />
Tabelle 14: Beispielhafter Time-Dimensionstable für die Anwendung ....................... 186<br />
- 254 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
12 ANHANG<br />
12.1 QUELLCODE DER ANWENDUNG<br />
12.1.1 PROGRAMM QUELLCODE APAWIN<br />
program APAWin;<br />
uses<br />
Forms,<br />
APA_Applicationunit in '..\Units\APA_Applicationunit.pas' {APA_Application},<br />
APA_Gridunit in '..\Units\APA_Gridunit.pas' {APA_Grid},<br />
APA_Input_Dimensionunit in '..\Units\APA_Input_Dimensionunit.pas'<br />
{APA_Insert_Dimension},<br />
APA_Input_Hierarchyunit in '..\Units\APA_Input_Hierarchyunit.pas'<br />
{APA_Insert_Hierarchy},<br />
APA_Input_Reqblockunit in '..\Units\APA_Input_Reqblockunit.pas' {APA_Insert_Reqblock},<br />
APA_Input_Screenunit in '..\Units\APA_Input_Screenunit.pas' {APA_Input_Screen},<br />
APA_Keyunit in '..\Units\APA_Keyunit.pas' {APA_Insert_Key},<br />
APA_Optionsunit in '..\Units\APA_Optionsunit.pas' {APA_Options},<br />
APA_Parameterunit in '..\Units\APA_Parameterunit.pas' {APA_Parameter},<br />
APA_Selectionunit in '..\Units\APA_Selectionunit.pas' {APA_Selection_Screen},<br />
APA_Analyseunit in '..\Units\APA_Analyseunit.pas' {APA_Analyse},<br />
APA_Screenunit in '..\Units\APA_Screenunit.pas' {APA_Screen},<br />
APA_Show_costsunit in '..\Units\APA_Show_costsunit.pas' {APA_Showcosts},<br />
APA_Processunit in '..\Units\APA_Processunit.pas' {APA_Show_Process},<br />
APA_Sqlunit in '..\Units\APA_Sqlunit.pas' {APA_Sql},<br />
APA_Dialogunit in '..\Units\APA_Dialogunit.pas' {APA_Dialog},<br />
APA_Helpunit in '..\Units\APA_Helpunit.pas' {APA_Help};<br />
{$R *.res}<br />
begin<br />
Application.Initialize;<br />
Application.Title := 'APA Application';<br />
Application.CreateForm(TAPA_Screen, APA_Screen);<br />
Application.CreateForm(TAPA_Application, APA_Application);<br />
Application.CreateForm(TAPA_Grid, APA_Grid);<br />
Application.CreateForm(TAPA_Insert_Dimension, APA_Insert_Dimension);<br />
Application.CreateForm(TAPA_Insert_Hierarchy, APA_Insert_Hierarchy);<br />
Application.CreateForm(TAPA_Insert_Reqblock, APA_Insert_Reqblock);<br />
Application.CreateForm(TAPA_Input_Screen, APA_Input_Screen);<br />
Application.CreateForm(TAPA_Insert_Key, APA_Insert_Key);<br />
Application.CreateForm(TAPA_Options, APA_Options);<br />
Application.CreateForm(TAPA_Parameter, APA_Parameter);<br />
Application.CreateForm(TAPA_Selection_Screen, APA_Selection_Screen);<br />
Application.CreateForm(TAPA_Analyse, APA_Analyse);<br />
Application.CreateForm(TAPA_Showcosts, APA_Showcosts);<br />
Application.CreateForm(TAPA_Show_Process, APA_Show_Process);<br />
Application.CreateForm(TAPA_Sql, APA_Sql);<br />
Application.CreateForm(TAPA_Dialog, APA_Dialog);<br />
Application.CreateForm(TAPA_Help, APA_Help);<br />
Application.Run;<br />
end.<br />
12.1.2 UNIT APA_ANALYSEUNIT.DFM<br />
object APA_Analyse: TAPA_Analyse<br />
Left = 220<br />
Top = 114<br />
Width = 696<br />
Height = 480<br />
Caption = 'APA_Analyse'<br />
Color = clBtnFace<br />
Font.Charset = DEFAULT_CHARSET<br />
Font.Color = clWindowText<br />
- 255 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Font.Height = -11<br />
Font.Name = 'MS Sans Serif'<br />
Font.Style = []<br />
OldCreateOrder = False<br />
Position = poScreenCenter<br />
OnShow = FormShow<br />
PixelsPerInch = 96<br />
TextHeight = 13<br />
object Analysetext: TMemo<br />
Left = 0<br />
Top = 0<br />
Width = 688<br />
Height = 405<br />
Align = alClient<br />
ScrollBars = ssBoth<br />
TabOrder = 0<br />
end<br />
object Panel1: TPanel<br />
Left = 0<br />
Top = 405<br />
Width = 688<br />
Height = 41<br />
Align = alBottom<br />
TabOrder = 1<br />
object Button_Close: TButton<br />
Left = 16<br />
Top = 8<br />
Width = 75<br />
Height = 25<br />
Cancel = True<br />
Caption = 'Close'<br />
Default = True<br />
TabOrder = 0<br />
OnClick = Button_CloseClick<br />
end<br />
end<br />
end<br />
12.1.3 UNIT APA_ANALYSEUNIT.PAS<br />
unit APA_Analyseunit;<br />
interface<br />
uses<br />
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,<br />
Dialogs, StdCtrls, ExtCtrls;<br />
type<br />
TAPA_Analyse = class(TForm)<br />
Analysetext: TMemo;<br />
Panel1: TPanel;<br />
Button_Close: TButton;<br />
procedure FormShow(Sender: TObject);<br />
procedure Button_CloseClick(Sender: TObject);<br />
private<br />
{ Private-Deklarationen }<br />
public<br />
{ Public-Deklarationen }<br />
end;<br />
var<br />
APA_Analyse: TAPA_Analyse;<br />
implementation<br />
uses APA_Gridunit, APA_Parameterunit, APA_Applicationunit;<br />
{$R *.dfm}<br />
procedure TAPA_Analyse.FormShow(Sender: TObject);<br />
var counter, counter2,pos:longint;<br />
- 256 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
var anztupels:Int64;<br />
var anzrequired, anzmat:longint;<br />
var Countergebnisse,N,K,NK:Extended;<br />
var anznotredundant:longint;<br />
var aktzeile,aktspalte,count_of_derivates:longint;<br />
var derivspalte,derivzeile,possiblecubes:longint;<br />
begin<br />
//Anzeige der Analyse des BFT<br />
Analysetext.Lines.Clear;<br />
Analysetext.Lines.Add('Analysis of Base Fact Table (BFT):');<br />
Analysetext.Lines.Add('==================================');<br />
Analysetext.Lines.Add('');<br />
//Berechnen der Tupels im BFT table<br />
anztupels:=0;anzmat:=0;anzrequired:=0;anznotredundant:=0;<br />
for counter:=0 to anzd-1 do begin;<br />
anztupels:=anztupels+countdaten[counter,0];<br />
end;<br />
Analysetext.Lines.Add('Tupels from source: '+inttostr(anztupels));<br />
Analysetext.Lines.Add('');<br />
Analysetext.Lines.Add('List of Required cubes:');<br />
Analysetext.Lines.Add('===========================');<br />
for counter:=0 to anzzeilen-1 do begin<br />
for counter2:=0 to anzspalten-1 do begin<br />
if APA[counter2,counter].farbe=clYellow then begin<br />
anznotredundant:=anznotredundant+1;<br />
end;<br />
if APA[counter2,counter].interessant=true then begin<br />
anzrequired:=anzrequired+1;<br />
Analysetext.Lines.Add('Required cube: '+inttostr(counter2)+':'+inttostr(counter)+'<br />
'+APA[counter2,counter].kurzbez);<br />
end;<br />
end;<br />
end;<br />
Analysetext.Lines.Add('found '+inttostr(anzrequired)+' required cubes in<br />
'+inttostr(anznotredundant)+' not redundant cubes.');<br />
Analysetext.Lines.Add('');<br />
Analysetext.Lines.Add('List of Materialized cubes:');<br />
Analysetext.Lines.Add('===========================');<br />
for counter:=0 to anzzeilen-1 do begin<br />
for counter2:=0 to anzspalten-1 do begin<br />
if APA[counter2,counter].materalisieren=true then begin<br />
anzmat:=anzmat+1;<br />
Analysetext.Lines.Add('Materialized cube:<br />
'+inttostr(counter2)+':'+inttostr(counter)+' '+APA[counter2,counter].kurzbez);<br />
end;<br />
end;<br />
end;<br />
Analysetext.Lines.Add('found '+inttostr(anzmat)+' materialized cubes');<br />
Analysetext.Lines.Add('');<br />
Analysetext.Lines.Add('Deterministic solution:');<br />
Analysetext.Lines.Add('===========================');<br />
assignfile(fCountermerk,'C:\APADIR\DATA\Countermerk.dat');<br />
{$i-}<br />
reset(fCountermerk);<br />
{$i+}<br />
if ioresult0 then showmessage('Can not open File Countermerk.dat');<br />
assignfile(fCubes,'C:\APADIR\DATA\Cubes.dat');<br />
{$i-}<br />
reset(fCubes);<br />
{$i+}<br />
if ioresult0 then showmessage('Can not open File Cubes.dat');<br />
assignfile(fMerkkosten,'C:\APADIR\DATA\Merkkosten.dat');<br />
{$i-}<br />
- 257 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
reset(fMerkkosten);<br />
{$i+}<br />
if ioresult0 then showmessage('Can not open File Merkkosten.dat');<br />
try<br />
pos:=0;<br />
repeat;<br />
if (filesize(fCountermerk)>0) then begin;<br />
seek(fCountermerk,pos);<br />
read(fCountermerk,vCountermerk);<br />
seek(fCubes,round(vCountermerk.nr)-1);<br />
read(fCubes,vCubes);<br />
Analysetext.Lines.Add('Cube('+floattostr(vCountermerk.Lfnr)+'):'+floattostr(vCount<br />
ermerk.Nr)+' = ('<br />
+inttostr(vCubes.Spalte)+':'+inttostr(vCubes.Zeile)+')');<br />
end;<br />
pos:=pos+1;<br />
until pos>=filesize(fCountermerk);;<br />
if (filesize(fMerkkosten)>0) then<br />
begin;<br />
Analysetext.Lines.Add('');<br />
seek(fMerkkosten,0);<br />
read(fMerkkosten,vMerkkosten);<br />
Analysetext.Lines.Add('Costs: '+floattostr(vMerkkosten.Kosten));<br />
seek(fMerkkosten,1);<br />
read(fMerkkosten,vMerkkosten);<br />
Analysetext.Lines.Add('Space left: '+floattostr(vMerkkosten.Kosten));<br />
seek(fMerkkosten,2);<br />
read(fMerkkosten,vMerkkosten);<br />
Analysetext.Lines.Add('Time left: '+floattostr(vMerkkosten.Kosten));<br />
end;<br />
Analysetext.Lines.Add('');<br />
Analysetext.Lines.Add('Count of possible solution:');<br />
Analysetext.Lines.Add('===========================');<br />
{Berechne Possible Cubes}<br />
counter:=anzrequired;<br />
{1.b Setze Derivate zu}<br />
for aktzeile:=0 to anzzeilen-1 do begin<br />
for aktspalte:=0 to anzspalten-1 do begin<br />
if<br />
(APA[aktspalte,aktzeile].farbe=clYellow)and(APA[aktspalte,aktzeile].interessant=fa<br />
lse) then begin<br />
count_of_derivates:=0;<br />
for derivspalte:=0 to anzspalten-1 do begin;<br />
for derivzeile:=0 to anzzeilen-1 do begin;<br />
if (APA[derivspalte,derivzeile].interessant=true)and<br />
(APA[derivspalte,derivzeile].farbe=clYellow) then begin<br />
if APA_Grid.isderivat(aktspalte,aktzeile,derivspalte,derivzeile) then begin<br />
//Jetzt kontrollieren wir, ob dieser Würfel auch noch ein Derivat eines<br />
anderen Würfels<br />
count_of_derivates:=count_of_derivates+1;<br />
end;//Ende von derivat<br />
end;//Ende von interessant<br />
end;//of derivzeile<br />
end;//of derivsspalte<br />
- 258 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if count_of_derivates>=1 then begin<br />
Analysetext.Lines.Add('Possible cube:<br />
'+inttostr(aktspalte)+':'+inttostr(aktzeile)+' '+APA[aktspalte,aktzeile].kurzbez);<br />
counter:=counter+1;<br />
end;<br />
end//von Yellow<br />
else if<br />
(APA[aktspalte,aktzeile].farbe=clYellow)and(APA[aktspalte,aktzeile].interessant=tr<br />
ue) then<br />
Analysetext.Lines.Add('Possible and Required cube:<br />
'+inttostr(aktspalte)+':'+inttostr(aktzeile)+' '+APA[aktspalte,aktzeile].kurzbez);<br />
end;//aktspalte<br />
end;//aktzeile<br />
possiblecubes:=counter;<br />
Analysetext.Lines.Add('Found '+inttostr(possiblecubes)+' Possible Cubes');<br />
{Berechne Permutation}<br />
Countergebnisse:=0;<br />
N:=1;<br />
for counter2:=1 to possiblecubes do N:=N*counter2;<br />
Analysetext.Lines.Add('Possible Combinations Permutation: '+floattostr(N));<br />
for counter:=1 to possiblecubes do begin<br />
K:=1;<br />
for counter2:=1 to counter do K:=K*counter2; //K!<br />
NK:=1;<br />
for counter2:=1 to (possiblecubes-counter) do NK:=NK*counter2;<br />
Countergebnisse:=Countergebnisse+(N/(K*NK));<br />
end;<br />
Analysetext.Lines.Add('Possible Combinations Kombination:<br />
'+floattostr(Countergebnisse));<br />
finally<br />
CloseFile(fcountermerk);<br />
CloseFile(fMerkkosten);<br />
CloseFile(fCubes);<br />
end;<br />
end;<br />
procedure TAPA_Analyse.Button_CloseClick(Sender: TObject);<br />
begin<br />
Close;<br />
end;<br />
end.<br />
12.1.4 UNIT APA_APPLICATIONUNIT.DFM<br />
object APA_Application: TAPA_Application<br />
Left = 158<br />
Top = 115<br />
ActiveControl = APA_Input_Screen_button<br />
BorderStyle = bsSingle<br />
Caption = 'APA Application'<br />
ClientHeight = 522<br />
ClientWidth = 704<br />
Color = clBtnFace<br />
Font.Charset = DEFAULT_CHARSET<br />
Font.Color = clWindowText<br />
Font.Height = -11<br />
Font.Name = 'MS Sans Serif'<br />
Font.Style = []<br />
Menu = APA_Menu<br />
OldCreateOrder = False<br />
Position = poScreenCenter<br />
OnActivate = FormActivate<br />
OnCloseQuery = FormCloseQuery<br />
- 259 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
PixelsPerInch = 96<br />
TextHeight = 13<br />
object Image1: TImage<br />
Left = 0<br />
Top = 0<br />
Width = 704<br />
Height = 522<br />
Align = alClient<br />
Picture.Data = {<br />
07544269746D61702EEB1000424D2EEB1000000000003600000028000000C302<br />
00000A0200000100180000000000F8EA1000C30E0000C30E0000000000000000<br />
. . . . .<br />
. . . . .<br />
. . . . .<br />
5E4C5A5E4C5A5E4C5A5E4C5A5E4D5A5E4D5A5E4D5A5E4D5A5E4D5A5E4D5A5E4D<br />
5A5E4D5A5E4E5A5E4E5A5E4E5A5E4E5B5E4E5B5E6E7C80000000}<br />
end<br />
object APA_Input_Screen_button: TButton<br />
Left = 40<br />
Top = 152<br />
Width = 75<br />
Height = 25<br />
Caption = 'Input Screen'<br />
TabOrder = 0<br />
OnClick = APA_Input_Screen_buttonClick<br />
end<br />
object APA_Grid_button: TButton<br />
Left = 40<br />
Top = 408<br />
Width = 75<br />
Height = 25<br />
Caption = 'APA Grid'<br />
TabOrder = 1<br />
OnClick = APA_Grid_buttonClick<br />
end<br />
object Button_Apa_Selection: TButton<br />
Left = 328<br />
Top = 280<br />
Width = 123<br />
Height = 25<br />
Caption = 'APA Selection Screen'<br />
TabOrder = 2<br />
OnClick = Button_Apa_SelectionClick<br />
end<br />
object APA_Menu: TMainMenu<br />
Left = 528<br />
Top = 8<br />
object File1: TMenuItem<br />
Caption = 'File'<br />
object Open1: TMenuItem<br />
Caption = 'Open'<br />
OnClick = Open1Click<br />
end<br />
object Save1: TMenuItem<br />
Caption = 'Save'<br />
OnClick = Save1Click<br />
end<br />
object Saveas1: TMenuItem<br />
Caption = 'Save as ...'<br />
OnClick = Saveas1Click<br />
end<br />
object Exit1: TMenuItem<br />
Caption = 'Exit'<br />
OnClick = Exit1Click<br />
end<br />
end<br />
object Screens1: TMenuItem<br />
Caption = 'Screens'<br />
object InputScreen1: TMenuItem<br />
Caption = 'Input Screen'<br />
OnClick = InputScreen1Click<br />
end<br />
object APAGridScreen1: TMenuItem<br />
Caption = 'APA Grid Screen'<br />
- 260 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
OnClick = APAGridScreen1Click<br />
end<br />
object APASelectionScreen1: TMenuItem<br />
Caption = 'APA Selection Screen'<br />
OnClick = APASelectionScreen1Click<br />
end<br />
end<br />
object Berechnungen1: TMenuItem<br />
Caption = 'Random costs'<br />
object GeneriereZufallskosten1: TMenuItem<br />
Caption = 'Build random costs'<br />
OnClick = GeneriereZufallskosten1Click<br />
end<br />
object ShowRandomCosts1: TMenuItem<br />
Caption = 'Show random costs'<br />
OnClick = ShowRandomCosts1Click<br />
end<br />
object Restrictedcosts1: TMenuItem<br />
AutoCheck = True<br />
Caption = 'Restricted costs'<br />
Checked = True<br />
OnClick = Restrictedcosts1Click<br />
end<br />
end<br />
object Analyse1: TMenuItem<br />
Caption = 'Analyse'<br />
object AnalyseAPA1: TMenuItem<br />
Caption = 'Analyse APA'<br />
OnClick = AnalyseAPA1Click<br />
end<br />
end<br />
object Settings1: TMenuItem<br />
Caption = 'Settings'<br />
object Parameter1: TMenuItem<br />
Caption = 'Parameters'<br />
OnClick = Parameter1Click<br />
end<br />
object Options1: TMenuItem<br />
Caption = 'Options'<br />
OnClick = Options1Click<br />
end<br />
end<br />
object Help1: TMenuItem<br />
Caption = 'Help'<br />
object HelpfilesAPAprogram1: TMenuItem<br />
Caption = 'Help files APA program'<br />
OnClick = HelpfilesAPAprogram1Click<br />
end<br />
object HelpfilesforMainmenu1: TMenuItem<br />
Caption = 'Help files for Main menu'<br />
OnClick = HelpfilesforMainmenu1Click<br />
end<br />
end<br />
end<br />
object APASavedialog: TSaveDialog<br />
DefaultExt = 'apa'<br />
Filter = 'APA File|*.apa'<br />
InitialDir = 'c:\APADIR\Save'<br />
Left = 272<br />
Top = 168<br />
end<br />
object APAOpendialog: TOpenDialog<br />
DefaultExt = 'apa'<br />
Filter = 'APA File|*.apa'<br />
InitialDir = 'c:\APADIR\Save'<br />
Left = 368<br />
Top = 120<br />
end<br />
end<br />
- 261 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
12.1.5 UNIT APA_APPLICATIONUNIT.PAS<br />
unit APA_Applicationunit;<br />
interface<br />
uses<br />
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,<br />
Dialogs, Menus, StdCtrls, ExtCtrls, Math, ComCtrls, ShellCtrls;<br />
type Countertype=<br />
record<br />
Lfnr:Extended;<br />
Nr:Extended;<br />
end;<br />
type Cubestype=<br />
record<br />
Lfnr:Extended;<br />
Spalte:Longint;<br />
Zeile:Longint;<br />
Required:Longint;<br />
end;<br />
type Kostentype=<br />
record<br />
VonSpalte:Longint;<br />
VonZeile:Longint;<br />
ZuSpalte:Longint;<br />
ZuZeile:Longint;<br />
Query:Extended;<br />
Build:Extended;<br />
end;<br />
type Merkkostentype=<br />
record<br />
Lfnr:Extended;<br />
Kosten:Extended;<br />
end;<br />
type ReqCubestype=<br />
record<br />
Lfnr:Extended;<br />
Spalte:Longint;<br />
Zeile:Longint;<br />
end;<br />
type<br />
TAPA_Application = class(TForm)<br />
APA_Menu: TMainMenu;<br />
File1: TMenuItem;<br />
Open1: TMenuItem;<br />
Save1: TMenuItem;<br />
Saveas1: TMenuItem;<br />
Exit1: TMenuItem;<br />
Screens1: TMenuItem;<br />
InputScreen1: TMenuItem;<br />
APAGridScreen1: TMenuItem;<br />
APASelectionScreen1: TMenuItem;<br />
Berechnungen1: TMenuItem;<br />
Settings1: TMenuItem;<br />
Parameter1: TMenuItem;<br />
Options1: TMenuItem;<br />
Image1: TImage;<br />
APA_Input_Screen_button: TButton;<br />
APA_Grid_button: TButton;<br />
Button_Apa_Selection: TButton;<br />
APASavedialog: TSaveDialog;<br />
APAOpendialog: TOpenDialog;<br />
GeneriereZufallskosten1: TMenuItem;<br />
ShowRandomCosts1: TMenuItem;<br />
Restrictedcosts1: TMenuItem;<br />
Analyse1: TMenuItem;<br />
- 262 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
AnalyseAPA1: TMenuItem;<br />
Help1: TMenuItem;<br />
HelpfilesAPAprogram1: TMenuItem;<br />
HelpfilesforMainmenu1: TMenuItem;<br />
Shelldir: TShellTreeView;<br />
procedure Kostensortieren();<br />
function findkosten(vonspalte,vonzeile,zuspalte,zuzeile:longint):boolean;<br />
procedure Parameter1Click(Sender: TObject);<br />
procedure Lade(Filename:string);<br />
procedure Open1Click(Sender: TObject);<br />
procedure Speichern(Filename:string);<br />
procedure Saveas1Click(Sender: TObject);<br />
procedure Exit1Click(Sender: TObject);<br />
procedure InputScreen1Click(Sender: TObject);<br />
procedure APAGridScreen1Click(Sender: TObject);<br />
procedure APASelectionScreen1Click(Sender: TObject);<br />
procedure Options1Click(Sender: TObject);<br />
procedure APA_Input_Screen_buttonClick(Sender: TObject);<br />
procedure APA_Grid_buttonClick(Sender: TObject);<br />
procedure Button_Apa_SelectionClick(Sender: TObject);<br />
procedure FormActivate(Sender: TObject);<br />
procedure GeneriereZufallskosten1Click(Sender: TObject);<br />
procedure ShowRandomCosts1Click(Sender: TObject);<br />
procedure Save1Click(Sender: TObject);<br />
procedure FormCloseQuery(Sender: TObject; var CanClose: Boolean);<br />
procedure Restrictedcosts1Click(Sender: TObject);<br />
procedure AnalyseAPA1Click(Sender: TObject);<br />
procedure HelpfilesAPAprogram1Click(Sender: TObject);<br />
procedure HelpfilesforMainmenu1Click(Sender: TObject);<br />
procedure FormCreate(Sender: TObject);<br />
private<br />
{ Private-Deklarationen }<br />
public<br />
{ Public-Deklarationen }<br />
end;<br />
var<br />
APA_Application: TAPA_Application;<br />
first:boolean=true;<br />
APAFilename:string ='C:\APA\SAVE\Default.apa';<br />
mustsave:boolean =false;<br />
var Fcounter:file of Countertype;<br />
vcounter:Countertype;<br />
FCountermerk:file of Countertype;<br />
vcountermerk:Countertype;<br />
FCubes:file of Cubestype;<br />
vcubes:Cubestype;<br />
FKosten:file of Kostentype;<br />
vkosten:Kostentype;<br />
FMatCubes:file of ReqCubestype;<br />
vMatcubes:reqcubestype;<br />
FReqCubes:file of ReqCubestype;<br />
vreqcubes:ReqCubestype;<br />
FMerkkosten:file of Merkkostentype;<br />
vmerkkosten:Merkkostentype;<br />
implementation<br />
uses APA_Parameterunit, APA_Selectionunit, APA_Gridunit,<br />
APA_Optionsunit, APA_Analyseunit, APA_Input_Screenunit,<br />
APA_Show_costsunit, APA_Processunit, APA_Dialogunit, APA_Helpunit;<br />
{$R *.dfm}<br />
procedure TAPA_Application.Kostensortieren();<br />
var pos:longint;<br />
var k1,k2:Kostentype;<br />
var max:longint;<br />
begin<br />
max:=filesize(fKosten)-1;<br />
pos:=max;<br />
- 263 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
repeat;<br />
if (pos>=1) then begin<br />
seek(fKosten,pos);<br />
read(fKosten,k1);<br />
seek(fKosten,pos-1);<br />
read(fKosten,k2);<br />
if<br />
((k1.VonSpalte=k2.vonspalte)and(k1.VonZeile=k2.vonzeile)and(k1.ZuSpalte
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
then begin;bereich:=0;gefunden:=true;end<br />
else begin<br />
if (k1.VonSpalte
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Filename:='C:\APADIR\SAVE\Default.apa';<br />
assignfile(APA_File,'C:\APADIR\SAVE\Default.apa');<br />
reset(APA_File);<br />
end;<br />
first2:=true;<br />
APA_Input_Screen.Eingabe.Items.Clear;<br />
st:='';<br />
while (not eof(APA_File))and(st'Ende Req') do begin<br />
readln(APA_File,st);<br />
if (st'Ende Input')and(st'Ende Req')and(st'Ende Keybox') then begin<br />
st2:=copy(st,1,5);<br />
st3:=copy(st,6,5);<br />
st:=copy(st,11,500);<br />
if APA_Input_Screen.Eingabe.SelectedNil then begin<br />
while (APA_Input_Screen.Eingabe.Selected.GetNextnil) do<br />
APA_Input_Screen.Eingabe.Selected:=APA_Input_Screen.Eingabe.Selected.GetNext;<br />
end;<br />
if (strtoint(st3)=1) then begin<br />
if first2=true then begin<br />
APA_Input_Screen.Eingabe.Selected:=APA_Input_Screen.Eingabe.Items.Add(nil,st);<br />
APA_Input_Screen.Eingabe.Selected.ImageIndex:=strtoint(st3);<br />
APA_Input_Screen.Eingabe.Selected.SelectedIndex:=strtoint(st3);<br />
end<br />
else<br />
APA_Input_Screen.Eingabe.Selected:=APA_Input_Screen.Eingabe.Items.Add(APA_Input_Sc<br />
reen.Eingabe.Selected,<br />
st);<br />
APA_Input_Screen.Eingabe.Selected.ImageIndex:=strtoint(st3);<br />
APA_Input_Screen.Eingabe.Selected.SelectedIndex:=strtoint(st3);<br />
end else begin<br />
if APA_Input_Screen.Eingabe.Selected.Level=0 then<br />
APA_Input_Screen.Eingabe.Selected:=APA_Input_Screen.Eingabe.Items.AddChild(APA_Inp<br />
ut_Screen.Eingabe.Selected,<br />
st)<br />
else<br />
APA_Input_Screen.Eingabe.Selected:=APA_Input_Screen.Eingabe.Items.Add(APA_Input_Sc<br />
reen.Eingabe.Selected,<br />
st);<br />
APA_Input_Screen.Eingabe.Selected.ImageIndex:=strtoint(st3);<br />
APA_Input_Screen.Eingabe.Selected.SelectedIndex:=strtoint(st3);<br />
end;<br />
end;<br />
end;//Ende von while1<br />
APA_Selection_Screen.Req.items.clear;<br />
while (not eof(APA_File))and(st'Ende Input') do begin<br />
readln(APA_File,st);<br />
if (st'Ende Input')and(st'Ende Req')and(st'Ende Selection')and(st'Ende<br />
Keybox') then begin<br />
st2:=copy(st,1,5);<br />
st3:=copy(st,6,5);<br />
st:=copy(st,11,500);<br />
if APA_Input_Screen.Eingabe.SelectedNil then begin<br />
while (APA_Input_Screen.Eingabe.Selected.GetNextnil) do<br />
APA_Input_Screen.Eingabe.Selected:=APA_Input_Screen.Eingabe.Selected.GetNext;<br />
end;<br />
if (strtoint(st2)=0) then begin<br />
if first2=true then begin<br />
APA_Selection_Screen.Req.Selected:=APA_Selection_Screen.Req.Items.Add(nil,st);<br />
APA_Selection_Screen.Req.Selected.ImageIndex:=strtoint(st3);<br />
APA_Selection_Screen.Req.Selected.SelectedIndex:=strtoint(st3);<br />
end<br />
else<br />
- 266 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
APA_Selection_Screen.Req.Selected:=APA_Selection_Screen.Req.Items.Add(APA_Selectio<br />
n_Screen.Req.Selected,<br />
st);<br />
APA_Selection_Screen.Req.Selected.ImageIndex:=strtoint(st3);<br />
APA_Selection_Screen.Req.Selected.SelectedIndex:=strtoint(st3);<br />
end else begin<br />
if APA_Selection_Screen.Req.Selected.Level=0 then<br />
APA_Selection_Screen.Req.Selected:=APA_Selection_Screen.Req.Items.AddChild(APA_Sel<br />
ection_Screen.Req.Selected,<br />
st)<br />
else<br />
APA_Selection_Screen.Req.Selected:=APA_Selection_Screen.REq.Items.Add(APA_Selectio<br />
n_Screen.Req.Selected,<br />
st);<br />
APA_Selection_Screen.Req.Selected.ImageIndex:=strtoint(st3);<br />
APA_Selection_Screen.Req.Selected.SelectedIndex:=strtoint(st3);<br />
end;<br />
end;<br />
end;//Ende von while2<br />
APA_Selection_Screen.Listeint.Items.Clear;<br />
while ((not eof(APA_File))and(st'Ende Selection')) do begin<br />
readln(APA_File,st);<br />
if (st'Ende Input')and(st'Ende Req')and(st'Ende Selection')and(st'Ende<br />
Keybox') then begin<br />
APA_Selection_Screen.Listeint.Items.Add(st);<br />
end;<br />
end;//Ende von While3<br />
APA_Grid_button.Enabled:=true;<br />
Button_Apa_Selection.Enabled:=true;<br />
APA_Grid.bezeichnungenholen();<br />
generiereapaneu:=true;<br />
APA_Grid.FormShow(self);<br />
//Begin while 4<br />
Matcount:=0;<br />
while (not eof(APA_File)and(st'Ende Cubes')) do begin<br />
readln(APA_File,st);<br />
if (st'Ende Input')and(st'Ende Req')and(st'Ende Selection')and(st'Ende<br />
Keybox')and(st'Ende Cubes') then begin<br />
if copy(st,1,1)='R' then begin<br />
APA[strtoint(copy(st,2,30)),strtoint(copy(st,32,30))].interessant:=true;<br />
APA[strtoint(copy(st,2,30)),strtoint(copy(st,32,30))].gewicht:=strtofloat(copy(st,<br />
62,30));<br />
APA[strtoint(copy(st,2,30)),strtoint(copy(st,32,30))].gewichtlevel:=strtoint(copy(<br />
st,92,30));<br />
end;<br />
if copy(st,1,1)='M' then begin<br />
APA[strtoint(copy(st,2,30)),strtoint(copy(st,32,30))].materalisieren:=true;<br />
APA[strtoint(copy(st,2,30)),strtoint(copy(st,32,30))].matcount:=strtoint(copy(st,6<br />
2,30));<br />
Matcount:=Matcount+1;<br />
end;<br />
end;<br />
end;//Ende von While4<br />
APA_Input_Screen.Keybox.Clear;<br />
while ((not eof(APA_File))and(st'Ende Keybox')) do begin<br />
- 267 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
readln(APA_File,st);<br />
if (st'Ende Input')and(st'Ende Req')and(st'Ende Selection')and(st'Ende<br />
Keybox')and(st'Ende Cubes') then begin<br />
APA_Input_Screen.Keybox.Items.Add(st);<br />
end;<br />
end;//Ende von While5<br />
if (not eof(APA_File)) then begin<br />
readln(APA_File,st);<br />
APA_Parameter.APA_Thomas_timestore.text:=st;<br />
readln(APA_File,st);<br />
APA_Parameter.APA_Thomas_timeio.text:=st;<br />
readln(APA_File,st);<br />
APA_Parameter.APA_Thomas_avsizeoftupel.text:=st;<br />
readln(APA_File,st);<br />
APA_Parameter.APA_Thomas_timemax.text:=st;<br />
readln(APA_File,st);<br />
APA_Parameter.APA_Thomas_spacemax.text:=st;<br />
readln(APA_File,st);<br />
APA_Parameter.APA_Thomas_Importance.Position:=strtoint(st);<br />
readln(APA_File,st);<br />
APA_Parameter.APA_Thomas_Query_Importance.Position:=strtoint(st);<br />
readln(APA_File,st);<br />
if st'Ende Parameter' then begin<br />
APA_Parameter.APA_Thomas_newsetsoneachiteration.text:=st;<br />
readln(APA_File,st);<br />
APA_Parameter.APA_Thomas_countofsets.text:=st;<br />
readln(APA_File,st);<br />
end;<br />
if st'Ende Parameter' then begin<br />
APA_Parameter.APA_Thomas_timecpu.text:=st;<br />
readln(APA_File,st);<br />
end;<br />
if st'Ende Parameter' then begin<br />
if st='True' then<br />
Permutation:=true else Permutation:=false;<br />
readln(APA_File,st);<br />
end;<br />
if st'Ende Parameter' then begin<br />
APA_Parameter.APA_Thomas_querytimemax.text:=st;<br />
readln(APA_File,st);<br />
if st='True' then<br />
APA_Grid.Userandomcosts1.Checked:=true else APA_Grid.Userandomcosts1.Checked:=false;<br />
readln(APA_File,st);<br />
end;<br />
if (not(Eof(APA_File))) then begin<br />
st:='';APA_Parameter.APA_Degrees.clear;<br />
while(not(Eof(APA_File)))and(st'Ende Degrees') do begin<br />
readln(APA_File,st);<br />
if st'Ende Degrees' then APA_Parameter.APA_Degrees.Items.Add(st);<br />
end;<br />
st:='';APA_Parameter.APA_Degreecounts.Clear;<br />
while(not(Eof(APA_File)))and(st'Ende Degreescount') do begin<br />
readln(APA_File,st);<br />
if st'Ende Degreescount' then APA_Parameter.APA_Degreecounts.items.Add(st);<br />
end;<br />
for counter:=0 to 14 do begin<br />
readln(APA_File,st);<br />
DegreeColors[counter]:=strtoint(st);<br />
end;<br />
readln(APA_File,st);<br />
for counter:=0 to 14 do begin<br />
readln(APA_File,st);<br />
Othercolors[counter]:=strtoint(st);<br />
end;<br />
readln(APA_File,st);<br />
- 268 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
end;//Ende von Eof2 dient der Rückwärtskompartibilität<br />
end;//Ende von not EOF<br />
APA_Grid.materialzeichnen;<br />
finally<br />
CloseFile(APA_File);<br />
if uppercase(APAFilename)uppercase('C:\APADIR\SAVE\Default.apa')<br />
then<br />
APA_Application.Caption:='APA Application - '+APAFilename<br />
else<br />
APA_Application.Caption:='APA Application ';<br />
end;<br />
try<br />
APA_Show_Process.ausgabe('Loading costs');<br />
//Lade auch die Kosten<br />
//Lade aus Spezialdatei<br />
if fileexists(ExtractFilePath(filename)+<br />
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))-3)+'ape')<br />
then begin<br />
try<br />
fStreamLaden:=TFileStream.Create(ExtractFilePath(filename)+<br />
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))-<br />
3)+'ape',fmOpenRead);<br />
try<br />
fStreamSpeichern:=TFileStream.Create('C:\APADIR\DATA\Kosten.dat',fmCreate);<br />
fStreamSpeichern.CopyFrom(fStreamLaden, fStreamLaden.Size);<br />
finally<br />
freeandnil(fStreamSpeichern);<br />
end;<br />
finally<br />
freeandnil(fStreamLaden);<br />
end;<br />
end;<br />
APA_Show_Process.ausgabe('Loading solution costs');<br />
//Lade aus Spezialdatei<br />
if fileexists(ExtractFilePath(filename)+<br />
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))-3)+'apf')<br />
then begin<br />
try<br />
fStreamLaden:=TFileStream.Create(ExtractFilePath(filename)+<br />
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))-<br />
3)+'apf',fmOpenRead);<br />
try<br />
fStreamSpeichern:=TFileStream.Create('C:\APADIR\DATA\Merkkosten.dat',fmCreate);<br />
fStreamSpeichern.CopyFrom(fStreamLaden, fStreamLaden.Size);<br />
finally<br />
freeandnil(fStreamSpeichern);<br />
end;<br />
finally<br />
freeandnil(fStreamLaden);<br />
end;<br />
end;<br />
APA_Show_Process.ausgabe('Loading cubes');<br />
//Lade aus Spezialdatei<br />
if fileexists(ExtractFilePath(filename)+<br />
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))-3)+'apd')<br />
then begin<br />
try<br />
fStreamLaden:=TFileStream.Create(ExtractFilePath(filename)+<br />
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))-<br />
3)+'apd',fmOpenRead);<br />
- 269 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
try<br />
fStreamSpeichern:=TFileStream.Create('C:\APADIR\DATA\Cubes.dat',fmCreate);<br />
fStreamSpeichern.CopyFrom(fStreamLaden, fStreamLaden.Size);<br />
finally<br />
freeandnil(fStreamSpeichern);<br />
end;<br />
finally<br />
freeandnil(fStreamLaden);<br />
end;<br />
end;<br />
APA_Show_Process.ausgabe('Loading counter');<br />
//Lade aus Spezialdatei<br />
if fileexists(ExtractFilePath(filename)+<br />
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))-3)+'apb')<br />
then begin<br />
try<br />
fStreamLaden:=TFileStream.Create(ExtractFilePath(filename)+<br />
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))-<br />
3)+'apb',fmOpenRead);<br />
try<br />
end;<br />
fStreamSpeichern:=TFileStream.Create('C:\APADIR\DATA\Counter.dat',fmCreate);<br />
fStreamSpeichern.CopyFrom(fStreamLaden, fStreamLaden.Size);<br />
finally<br />
freeandnil(fStreamSpeichern);<br />
end;<br />
finally<br />
freeandnil(fStreamLaden);<br />
end;<br />
APA_Show_Process.ausgabe('Loading solution');<br />
//Lade aus Spezialdatei<br />
if fileexists(ExtractFilePath(filename)+<br />
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))-3)+'apc')<br />
then begin<br />
try<br />
fStreamLaden:=TFileStream.Create(ExtractFilePath(filename)+<br />
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))-<br />
3)+'apc',fmOpenRead);<br />
try<br />
end;<br />
fStreamSpeichern:=TFileStream.Create('C:\APADIR\DATA\Countermerk.dat',fmCreate);<br />
fStreamSpeichern.CopyFrom(fStreamLaden, fStreamLaden.Size);<br />
finally<br />
freeandnil(fStreamSpeichern);<br />
end;<br />
finally<br />
freeandnil(fStreamLaden);<br />
end;<br />
except<br />
showmessage('Could not load costs');<br />
fehler:=true;<br />
end;<br />
finally<br />
APA_Application.Enabled:=true;<br />
APA_Show_Process.ButtonCancel.Caption:='Close';<br />
if fehler=false then<br />
APA_Show_Process.Ausschalten.Enabled:=true<br />
else<br />
APA_Show_Process.ButtonCancel.Caption:='Close';<br />
mustsave:=false;<br />
end;<br />
end;<br />
procedure TAPA_Application.Open1Click(Sender: TObject);<br />
- 270 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
begin<br />
APAOpendialog.InitialDir:=<br />
APA_Options.APA_Save_Path.Directory;<br />
If APAOpendialog.Execute then begin<br />
if mustsave=true then begin<br />
APA_Dialog.APA_Text.Caption:='You did not save your APA. Do you want to save?';<br />
if APA_Dialog.showmodal=mryes then begin;<br />
if APAFilename='C:\APADIR\SAVE\Default.apa' then<br />
Saveas1Click(self) else<br />
Speichern(APAFilename);<br />
end;<br />
end;<br />
APAFilename:=APAOpendialog.FileName;<br />
Lade(APAFileName);<br />
end;<br />
end;<br />
procedure TAPA_Application.Speichern(Filename:string);<br />
var APA_File: TextFile;<br />
counter,counter2:longint;<br />
st:string;<br />
fStreamladen,fStreamspeichern:TFileStream;<br />
begin<br />
try<br />
APA_Show_Process.ButtonPause.Visible:=false;<br />
APA_Show_Process.show;<br />
APA_Show_Process.APA_Protocoll.Clear;<br />
APA_Show_Process.ausgabe('Saving File: '+Filename);<br />
APA_Show_Process.ausgabe('Save APA Data ...');<br />
APA_Application.Enabled:=false;<br />
assignfile(APA_File,APAFilename);<br />
try<br />
rewrite(APA_File);<br />
APA_Show_Process.ausgabe('Save APA Input Screen');<br />
for counter:=0 to APA_Input_Screen.Eingabe.Items.Count-1 do begin<br />
st:=APA_Grid.auffuellen(inttostr(APA_Input_Screen.Eingabe.Items[counter].Level),5)+<br />
APA_Grid.auffuellen(inttostr(APA_Input_Screen.Eingabe.Items[counter].Imageindex),5<br />
)+<br />
APA_Input_Screen.Eingabe.Items[counter].Text;<br />
writeln(APA_File,st);<br />
end;<br />
writeln(APA_File,'Ende Req');<br />
APA_Show_Process.ausgabe('Save APA Selection Screen');<br />
for counter:=0 to APA_Selection_Screen.Req.Items.Count-1 do begin<br />
st:=APA_Grid.auffuellen(inttostr(APA_Selection_Screen.Req.Items[counter].Level),5)+<br />
APA_Grid.auffuellen(inttostr(APA_Selection_Screen.Req.Items[counter].ImageIndex),5<br />
)+<br />
APA_Selection_Screen.Req.Items[counter].Text;<br />
writeln(APA_File,st);<br />
end;<br />
writeln(APA_File,'Ende Input');<br />
for counter:=0 to APA_Selection_Screen.Listeint.Items.Count-1 do begin<br />
st:=APA_Selection_Screen.Listeint.Items[counter];<br />
writeln(APA_File,st);<br />
end;<br />
writeln(APA_File,'Ende Selection');<br />
APA_Show_Process.ausgabe('Save required and materialized cubes');<br />
for counter:=0 to anzzeilen-1 do begin<br />
for counter2:=0 to anzspalten-1 do begin<br />
- 271 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if (APA[counter2,counter].interessant=true) then begin<br />
st:='R'+APA_Grid.auffuellen(inttostr(counter2),30)+APA_Grid.auffuellen(inttostr(co<br />
unter),30)+<br />
APA_Grid.auffuellen(floattostr(APA[counter2,counter].gewicht),30)+APA_Grid.auffuel<br />
len(inttostr(APA[counter2,counter].gewichtlevel),30);<br />
writeln(APA_File,st);<br />
end;<br />
if (APA[counter2,counter].materalisieren=true) then begin<br />
st:='M'+APA_Grid.auffuellen(inttostr(counter2),30)+APA_Grid.auffuellen(inttostr(co<br />
unter),30)+<br />
APA_Grid.auffuellen(inttostr(APA[counter2,counter].matcount),30);<br />
writeln(APA_File,st);<br />
end;<br />
end;<br />
end;<br />
writeln(APA_File,'Ende Cubes');<br />
APA_Show_Process.ausgabe('Save APA Input Screen Keybox');<br />
for counter:=0 to APA_Input_Screen.keybox.Items.Count-1 do begin<br />
writeln(APA_File,APA_Input_Screen.keybox.Items[counter]);<br />
end;<br />
writeln(APA_File,'Ende Keybox');<br />
APA_Show_Process.ausgabe('Save APA Parameter');<br />
writeln(APA_File,APA_Parameter.APA_Thomas_timestore.text);<br />
writeln(APA_File,APA_Parameter.APA_Thomas_timeio.text);<br />
writeln(APA_File,APA_Parameter.APA_Thomas_avsizeoftupel.text);<br />
writeln(APA_File,APA_Parameter.APA_Thomas_timemax.text);<br />
writeln(APA_File,APA_Parameter.APA_Thomas_spacemax.text);<br />
writeln(APA_File,inttostr(APA_Parameter.APA_Thomas_Importance.Position));<br />
writeln(APA_File,inttostr(APA_Parameter.APA_Thomas_Query_Importance.Position));<br />
writeln(APA_File,APA_Parameter.APA_Thomas_newsetsoneachiteration.text);<br />
writeln(APA_File,APA_Parameter.APA_Thomas_countofsets.text);<br />
writeln(APA_File,APA_Parameter.APA_Thomas_timecpu.text);<br />
if Permutation=true then<br />
writeln(APA_File,'True')else writeln(APA_File,'False');<br />
writeln(APA_File,APA_Parameter.APA_Thomas_querytimemax.text);<br />
if APA_Grid.Userandomcosts1.Checked=true then<br />
writeln(APA_File,'True')else writeln(APA_File,'False');<br />
writeln(APA_File,'Ende Parameter');<br />
for counter:=0 to APA_Parameter.APA_Degrees.Items.Count-1 do begin<br />
writeln(APA_File,APA_Parameter.APA_Degrees.Items[counter]);<br />
end;<br />
writeln(APA_File,'Ende Degrees');<br />
for counter:=0 to APA_Parameter.APA_Degreecounts.Items.Count-1 do begin<br />
writeln(APA_File,APA_Parameter.APA_Degreecounts.Items[counter]);<br />
end;<br />
writeln(APA_File,'Ende Degreescount');<br />
for counter:=0 to 14 do begin<br />
writeln(APA_File,inttostr(DegreeColors[counter]));<br />
end;<br />
writeln(APA_File,'Ende Farben');<br />
for counter:=0 to 14 do begin<br />
writeln(APA_File,inttostr(Othercolors[counter]));<br />
end;<br />
writeln(APA_File,'Ende Andere Farben');<br />
finally<br />
Closefile(APA_File);<br />
APA_Application.Caption:='APA Application - '+APAFilename;<br />
- 272 -
try<br />
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
end;<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
APA_Show_Process.ausgabe('Save costs');<br />
//Speichere auch die Kosten<br />
//Speichere in Spezialdatei<br />
{$i-}<br />
CloseFile(fKosten);<br />
{$i+}<br />
if ioresult0 then APA_Show_Process.ausgabe('Close cost database');<br />
try<br />
fStreamLaden:=TFileStream.Create('C:\APADIR\DATA\Kosten.dat',fmOpenRead);<br />
try<br />
fStreamSpeichern:=TFileStream.Create(ExtractFilePath(filename)+<br />
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))-<br />
3)+'ape',fmCreate);<br />
fStreamSpeichern.CopyFrom(fStreamLaden, fStreamLaden.Size);<br />
finally<br />
freeandnil(fStreamSpeichern);<br />
end;<br />
finally<br />
freeandnil(fStreamLaden);<br />
end;<br />
APA_Show_Process.ausgabe('Save solution');<br />
//Speichere in Spezialdatei<br />
try<br />
fStreamLaden:=TFileStream.Create('C:\APADIR\DATA\Countermerk.dat',fmOpenRead);<br />
try<br />
fStreamSpeichern:=TFileStream.Create(ExtractFilePath(filename)+<br />
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))-<br />
3)+'apc',fmCreate);<br />
fStreamSpeichern.CopyFrom(fStreamLaden, fStreamLaden.Size);<br />
finally<br />
freeandnil(fStreamSpeichern);<br />
end;<br />
finally<br />
freeandnil(fStreamLaden);<br />
end;<br />
APA_Show_Process.ausgabe('Save cubes');<br />
//Speichere in Spezialdatei<br />
try<br />
fStreamLaden:=TFileStream.Create('C:\APADIR\DATA\Cubes.dat',fmOpenRead);<br />
try<br />
fStreamSpeichern:=TFileStream.Create(ExtractFilePath(filename)+<br />
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))-<br />
3)+'apd',fmCreate);<br />
fStreamSpeichern.CopyFrom(fStreamLaden, fStreamLaden.Size);<br />
finally<br />
freeandnil(fStreamSpeichern);<br />
end;<br />
finally<br />
freeandnil(fStreamLaden);<br />
end;<br />
APA_Show_Process.ausgabe('Save counter');<br />
//Speichere in Spezialdatei<br />
try<br />
fStreamLaden:=TFileStream.Create('C:\APADIR\DATA\Counter.dat',fmOpenRead);<br />
try<br />
fStreamSpeichern:=TFileStream.Create(ExtractFilePath(filename)+<br />
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))-<br />
3)+'apb',fmCreate);<br />
fStreamSpeichern.CopyFrom(fStreamLaden, fStreamLaden.Size);<br />
finally<br />
freeandnil(fStreamSpeichern);<br />
end;<br />
finally<br />
freeandnil(fStreamLaden);<br />
end;<br />
- 273 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
APA_Show_Process.ausgabe('Save solution costs');<br />
//Speichere in Spezialdatei<br />
try<br />
fStreamLaden:=TFileStream.Create('C:\APADIR\DATA\Merkkosten.dat',fmOpenRead);<br />
try<br />
fStreamSpeichern:=TFileStream.Create(ExtractFilePath(filename)+<br />
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))-<br />
3)+'apf',fmCreate);<br />
fStreamSpeichern.CopyFrom(fStreamLaden, fStreamLaden.Size);<br />
finally<br />
freeandnil(fStreamSpeichern);<br />
end;<br />
finally<br />
freeandnil(fStreamLaden);<br />
end;<br />
except<br />
showmessage('Could not save costs');<br />
end;<br />
finally<br />
APA_Show_Process.ButtonCancel.Caption:='Close';<br />
APA_Show_Process.Ausschalten.Enabled:=true;<br />
APA_Application.Enabled:=true;<br />
mustsave:=false;<br />
end;<br />
end;<br />
procedure TAPA_Application.Saveas1Click(Sender: TObject);<br />
begin<br />
APASavedialog.InitialDir:=<br />
APA_Options.APA_Save_Path.Directory;<br />
if APASavedialog.Execute then begin<br />
APAFilename:= APASavedialog.FileName;<br />
Speichern(APAFilename);<br />
end;<br />
end;<br />
procedure TAPA_Application.Exit1Click(Sender: TObject);<br />
begin<br />
Close;<br />
end;<br />
procedure TAPA_Application.InputScreen1Click(Sender: TObject);<br />
begin<br />
APA_Input_Screen_buttonClick(self);<br />
end;<br />
procedure TAPA_Application.APAGridScreen1Click(Sender: TObject);<br />
begin<br />
APA_Grid_buttonClick(self);<br />
end;<br />
procedure TAPA_Application.APASelectionScreen1Click(Sender: TObject);<br />
begin<br />
Button_Apa_SelectionClick(self);<br />
end;<br />
procedure TAPA_Application.Options1Click(Sender: TObject);<br />
begin<br />
APA_Options.showmodal;<br />
end;<br />
procedure TAPA_Application.APA_Input_Screen_buttonClick(Sender: TObject);<br />
begin<br />
APA_Application.Hide;<br />
try<br />
APA_Input_Screen.ShowModal<br />
finally<br />
- 274 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
APA_Application.Show;<br />
end;<br />
end;<br />
procedure TAPA_Application.APA_Grid_buttonClick(Sender: TObject);<br />
begin<br />
APA_Application.Hide;<br />
{Generieren des APA }<br />
try<br />
gotoInput:=false;<br />
gotoSelection:=false;<br />
bezeichnungenkontrolliert:=false;<br />
APA_Grid.bezeichnungenholen();<br />
if bezeichnungenkontrolliert=true then begin;<br />
APA_Grid.WindowState:=wsMaximized;<br />
APA_Grid.showmodal;<br />
Button_APA_Selection.Enabled:=true;<br />
end else<br />
begin;<br />
gotoInput:=true;<br />
end;<br />
if gotoInput=true then begin;gotoInput:=false;APA_Input_Screen_button.Click;end;<br />
if gotoSelection=true then begin;gotoSelection:=false;Button_Apa_Selection.Click;end;<br />
finally<br />
APA_Application.Show;<br />
end;<br />
end;<br />
procedure TAPA_Application.Button_Apa_SelectionClick(Sender: TObject);<br />
var zahler:longint;<br />
begin<br />
APA_Application.Hide;<br />
try<br />
{Laden der möglichen Dimensionen und Hierarchiestufen}<br />
{1. Dimensionen laden}<br />
with APA_Selection_Screen do begin<br />
Dimensionbox.Items.Clear;<br />
Hierarchybox.Items.Clear;<br />
for zahler:= 0 to anzd-1 do begin<br />
Dimensionbox.Items.Add(dimbez[zahler]);<br />
end;<br />
Dimensionbox.itemindex:=0;<br />
{Füllen der Hierarchien}<br />
hierarchybox.Items.Clear;<br />
{Hole die Hierarchiestufen}<br />
for zahler:=0 to anzh[Dimensionbox.itemindex]-1 do begin<br />
Hierarchybox.Items.Add(dl[Dimensionbox.itemindex][zahler])<br />
end;<br />
Hierarchybox.ItemIndex:=0;<br />
Methodbox.ItemIndex:=0;<br />
End_of_methodbox.Enabled:=false;<br />
end;{Ende von APA_Selection_Screen}<br />
APA_Selection_Screen.WindowState:=wsMaximized;<br />
APA_Selection_Screen.showmodal;<br />
if gotoAPA=true then begin;gotoAPA:=false;APA_Grid_Button.Click;end;<br />
finally<br />
- 275 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
APA_Application.Show;<br />
end;<br />
end;<br />
procedure TAPA_Application.FormActivate(Sender: TObject);<br />
var merkfile:TextFile;<br />
st:string;<br />
var fStreamladen,fStreamspeichern:TFileStream;<br />
begin<br />
if first=true then begin;<br />
{showmessage('Dies ist eine Betaversion. Für Fehler oder unrichtige Ergebnisse wird<br />
keine Garantie übernommen. c)Thomas ACHS');}<br />
first:=false;<br />
assignfile(merkfile,'C:\APADIR\PROGRAM\Settings.tom');<br />
try<br />
reset(merkfile);<br />
readln(merkfile,APAFilename);<br />
readln(merkfile,st);<br />
if st='True' then<br />
APA_Options.APA_Load_Last_APA.Checked:=true else<br />
APA_Options.APA_Load_Last_APA.Checked:=false;<br />
readln(merkfile,st);<br />
if st='True' then<br />
APA_Options.APA_Save_on_termination.Checked:=true else<br />
APA_Options.APA_Save_on_termination.Checked:=false;<br />
readln(merkfile,st);<br />
if st='True' then<br />
APA_Options.APA_Remove_redundancy.Checked:=true else<br />
APA_Options.APA_Remove_redundancy.Checked:=false;<br />
APA_Grid.Remove_Redundancy.Checked:=APA_Options.APA_Remove_redundancy.Checked;<br />
readln(merkfile,st);<br />
if st='True' then<br />
APA_Options.APA_Add_max_hier.Checked:=true else<br />
APA_Options.APA_Add_max_hier.Checked:=false;<br />
readln(merkfile,st); //Früher Saverandomcosts<br />
if st='True' then<br />
APA_Options.APA_Show_Link_on_Desktop.Checked:=true else<br />
APA_Options.APA_Show_Link_on_Desktop.Checked:=false;<br />
readln(merkfile,st);<br />
APA_Options.APA_Save_Path.Directory:=st;<br />
if not(eof(merkfile)) then begin<br />
readln(merkfile,st);<br />
if st='True' then<br />
APA_Options.APA_ShowScreenheuristic.Checked:=true else<br />
APA_Options.APA_ShowScreenheuristic.Checked:=false;<br />
end;<br />
finally<br />
Closefile(merkfile);<br />
end;<br />
if APA_Options.APA_Load_Last_APA.Checked=true then begin<br />
//Lade<br />
Lade(APAFilename);<br />
end else begin;<br />
Lade('c:\APADIR\Save\Default.APA');<br />
end;<br />
if APA_Options.APA_Show_Link_on_Desktop.Checked=true then begin<br />
if fileexists(shelldir.Path+'\APAWin.lnk')=false then begin<br />
try<br />
- 276 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
fStreamLaden:=TFileStream.Create('c:\APADIR\PROGRAM\APAWin.lnk',fmOpenRead);<br />
try<br />
fStreamSpeichern:=TFileStream.Create(shelldir.Path+'\APAWin.lnk',fmCreate);<br />
fStreamSpeichern.CopyFrom(fStreamLaden, fStreamLaden.Size);<br />
finally<br />
freeandnil(fStreamSpeichern);<br />
end;<br />
finally<br />
freeandnil(fStreamLaden);<br />
end;<br />
end else begin<br />
//Löschen<br />
if fileexists(shelldir.Path+'\APAWin.lnk')=true then begin<br />
try<br />
deletefile(shelldir.Path+'\APAWin.lnk');<br />
except<br />
showmessage('Can not remove link from Desktop');<br />
end;<br />
end;<br />
end;<br />
end;<br />
end;<br />
end;<br />
procedure TAPA_Application.GeneriereZufallskosten1Click(Sender: TObject);<br />
var hauptspalte,hauptzeile,aktspalte,aktzeile:longint;<br />
Maxkosten, maxkosten2,KostenvomBFT,<br />
KostenvomBFT2, KostenParent,KostenParent2:longint;<br />
costmerk:longint;<br />
parentspalte,parentzeile:longint;<br />
bandbreite:longint;<br />
begin<br />
if generiereapaneu=true then begin<br />
APA_Grid.FormShow(self);<br />
end;<br />
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');<br />
{$i-}<br />
rewrite(fKosten);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('cost database error ');exit;end;<br />
try<br />
APA_Show_Process.ButtonPause.Visible:=false;<br />
APA_Show_Process.show;<br />
APA_Application.Enabled:=false;<br />
bandbreite:=100000;<br />
stop:=false;<br />
APA_Show_Process.APA_Protocoll.Clear;<br />
APA_Show_Process.ausgabe('Build Costs ...');<br />
Randomize;<br />
//Zuerst lösche alle alten Kosten aus der Tabelle<br />
APA_Show_Process.ausgabe('Clear costs...');<br />
//Generiere alle Kanten indem von jedem Würfel die Kanten zu allen seinen Derivaten<br />
bewertet werden<br />
//und die Kosten vom BFT zu dem Würfel die max Kosten sind 10000<br />
if APA_Application.Restrictedcosts1.Checked=true then begin<br />
//**************************************<br />
// Erster Lauf<br />
//**************************************<br />
//Bewerte alle Kosten aus dem BFT<br />
- 277 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
for hauptspalte:=0 to anzspalten-1 do begin<br />
for hauptzeile:=0 to anzzeilen-1 do begin<br />
if APA[hauptspalte,hauptzeile].farbe=clYellow then begin<br />
//Suche alle Parents und merke die die geringsten Kosten des Parents<br />
maxkosten2:=bandbreite;<br />
maxkosten:=bandbreite;<br />
for aktspalte:=0 to anzspalten-1 do begin<br />
for aktzeile:=0 to anzzeilen-1 do begin<br />
if APA[aktspalte,aktzeile].farbe=clYellow then begin<br />
if<br />
(APA_Grid.isderivat(aktspalte,aktzeile,hauptspalte,hauptzeile)=true)<br />
and (not((hauptspalte=aktspalte)and(hauptzeile=aktzeile))) then<br />
begin<br />
if findkosten(-1,-1,aktspalte,aktzeile)=true then begin<br />
if vkosten.Query
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
If (APA_Grid.isderivat(aktspalte,aktzeile,hauptspalte,hauptzeile)=true)and<br />
(not((hauptspalte=aktspalte)and(hauptzeile=aktzeile)))<br />
//Der Parent aggregiert die gleiche Dimension<br />
then begin<br />
//Suche Maxkosten vom BFT<br />
if (findkosten(-1,-1,hauptspalte,hauptzeile)=true) then begin<br />
maxkosten:=round(vkosten.Build);<br />
maxkosten2:=round(vKosten.Query);<br />
end else begin<br />
maxkosten:=bandbreite;<br />
maxkosten2:=bandbreite;<br />
end;<br />
//Kosten der Materialisierung vom BFT<br />
costmerk:=round(APA_Grid.getbuild(-1,-1,hauptspalte,hauptzeile));<br />
if (costmerk
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
end;//aktzeile<br />
end;//aktspalte<br />
end;//Ende von nicht Redundant<br />
end;//Ende Zeile<br />
end;//Ende Spalte<br />
end // von total Random costs<br />
else begin<br />
for hauptzeile:=0 to anzzeilen-1 do begin<br />
for hauptspalte:=0 to anzspalten-1 do begin<br />
if APA[hauptspalte,hauptzeile].farbe=clYellow then begin<br />
{1.Generiere Kosten von BFT}<br />
KostenvomBFT:=1+random(bandbreite-1);//Materialisierungskosten<br />
KostenvomBFT2:=1+random(KostenvomBFT-1);//Abfragekosten<br />
APA_Show_Process.ausgabe('Build BFT('+inttostr(hauptspalte)+<br />
':'+inttostr(hauptzeile)+'):<br />
'+inttostr(KostenvomBFT2)+'/'+inttostr(KostenvomBFT));<br />
//Eintragen der Kosten vom BFT<br />
seek(fKosten,filesize(fKosten));<br />
vKosten.VonSpalte:=-1;<br />
vKosten.VonZeile:=-1;<br />
vKosten.ZuSpalte:=hauptspalte;<br />
vKosten.ZUZeile:=hauptzeile;<br />
vKosten.Query:=KostenvomBFT2;<br />
vKosten.Build:=KostenvomBFT;<br />
write(fKosten,vKosten);Kostensortieren;<br />
{2.Generiere Kosten aller Derivate}<br />
for aktspalte:=0 to anzspalten-1 do begin<br />
for aktzeile:=0 to anzzeilen-1 do begin<br />
if (APA[aktspalte,aktzeile].farbe=clYellow) then begin<br />
if (APA_Grid.isderivat(hauptspalte,hauptzeile,aktspalte,aktzeile)) then begin<br />
//Eintragen der Kosten<br />
KostenvomBFT:=1+random(bandbreite-1);//Materialisierungskosten<br />
KostenvomBFT2:=1+random(KostenvomBFT-1);//Abfragekosten<br />
APA_Show_Process.ausgabe('Build from ('+inttostr(hauptspalte)+':'+<br />
inttostr(hauptzeile)+') to ('+inttostr(aktspalte)+':'+<br />
inttostr(aktzeile)+'):<br />
'+inttostr(KostenvomBFT2)+'/'+inttostr(KostenvomBFT));<br />
//Eintragen der Kosten vom BFT<br />
seek(fKosten,filesize(fKosten));<br />
vKosten.VonSpalte:=hauptspalte;<br />
vKosten.VonZeile:=hauptzeile;<br />
vKosten.ZuSpalte:=aktspalte;<br />
vKosten.ZUZeile:=aktzeile;<br />
vKosten.Query:=KostenvomBFT2;<br />
vKosten.Build:=KostenvomBFT;<br />
write(fKosten,vKosten); Kostensortieren;<br />
end;//isderivat<br />
end;//not redundant<br />
end;//aktzeile<br />
end;//aktspalte<br />
end;//not redundant<br />
end;//hauptspalte<br />
end;//hauptzeile<br />
end;<br />
finally<br />
CloseFile(fKosten);<br />
APA_Application.Enabled:=true;<br />
end;<br />
APA_Show_Process.ButtonCancel.Caption:='Close';<br />
APA_Showcosts.showmodal;<br />
mustsave:=true;<br />
- 280 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
end;<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
APA_Show_Process.ausgabe('');<br />
APA_Show_Process.ausgabe('READY');<br />
APA_Show_Process.ausgabe('');<br />
procedure TAPA_Application.ShowRandomCosts1Click(Sender: TObject);<br />
begin<br />
APA_Showcosts.showmodal;<br />
end;<br />
procedure TAPA_Application.Save1Click(Sender: TObject);<br />
begin<br />
if uppercase(APAFilename)=uppercase('C:\APADIR\SAVE\Default.apa') then<br />
Saveas1Click(self) else<br />
Speichern(APAFilename);<br />
end;<br />
procedure TAPA_Application.FormCloseQuery(Sender: TObject;<br />
var CanClose: Boolean);<br />
var merkfile:TextFile;<br />
begin<br />
if APA_Options.APA_Save_on_termination.Checked=true then begin<br />
if mustsave=true then Speichern(Apafilename);<br />
end;<br />
if mustsave=true then begin<br />
APA_Dialog.APA_Text.Caption:='You did not save your APA. Do you want to save?';<br />
end;<br />
if APA_Dialog.showmodal=mryes then begin;<br />
Save1Click(self);<br />
end;<br />
assignfile(merkfile,'C:\APADIR\PROGRAM\Settings.tom');<br />
try<br />
rewrite(merkfile);<br />
writeln(merkfile,APAFilename);<br />
if APA_Options.APA_Load_Last_APA.Checked=true then<br />
writeln(merkfile,'True') else<br />
writeln(merkfile,'False');<br />
if APA_Options.APA_Save_on_termination.Checked=true then<br />
writeln(merkfile,'True') else<br />
writeln(merkfile,'False');<br />
if APA_Options.APA_Remove_redundancy.Checked=true then<br />
writeln(merkfile,'True') else<br />
writeln(merkfile,'False');<br />
if APA_Options.APA_Add_max_hier.Checked=true then<br />
writeln(merkfile,'True') else<br />
writeln(merkfile,'False');<br />
if APA_Options.APA_Show_Link_on_Desktop.Checked=true then<br />
writeln(merkfile,'True')<br />
else<br />
writeln(merkfile,'False');<br />
writeln(merkfile,APA_Options.APA_Save_Path.Directory);<br />
if APA_Options.APA_ShowScreenheuristic.Checked=true then<br />
writeln(merkfile,'True') else<br />
writeln(merkfile,'False');<br />
finally<br />
Closefile(merkfile);<br />
end;<br />
end;<br />
- 281 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
procedure TAPA_Application.Restrictedcosts1Click(Sender: TObject);<br />
begin<br />
APA_Grid.Restrictedcosts1.Checked:=APA_Application.Restrictedcosts1.Checked;<br />
end;<br />
procedure TAPA_Application.AnalyseAPA1Click(Sender: TObject);<br />
begin<br />
if generiereapaneu=true then begin<br />
APA_Grid.FormShow(self);<br />
end;<br />
APA_Analyse.show;<br />
end;<br />
procedure TAPA_Application.HelpfilesAPAprogram1Click(Sender: TObject);<br />
begin<br />
APA_Help.show;<br />
APA_Help.APABrowser.Navigate('C:\APADIR\Help\index.htm');<br />
end;<br />
procedure TAPA_Application.HelpfilesforMainmenu1Click(Sender: TObject);<br />
begin<br />
APA_Help.show;<br />
APA_Help.APABrowser.Navigate('C:\APADIR\Help\APA_Mainmenu.htm');<br />
end;<br />
procedure TAPA_Application.FormCreate(Sender: TObject);<br />
begin<br />
CurrencyString:='';<br />
ShortDateFormat:='dd.mm.yyyy';<br />
LongDateFormat:='dd.mm.yyyy';<br />
DateSeparator := '.';<br />
ThousandSeparator:='.';<br />
DecimalSeparator:=',';<br />
CurrencyDecimals:=2;<br />
ShortTimeFormat:='hh:nn';<br />
LongTimeFormat:='hh:nn';<br />
end;<br />
end.<br />
12.1.6 UNIT APA_DIALOGUNIT.DFM<br />
object APA_Screen: TAPA_Screen<br />
Left = 220<br />
Top = 114<br />
Width = 696<br />
Height = 480<br />
Caption = 'APA_Screen'<br />
Color = clBtnFace<br />
Font.Charset = DEFAULT_CHARSET<br />
Font.Color = clWindowText<br />
Font.Height = -11<br />
Font.Name = 'MS Sans Serif'<br />
Font.Style = []<br />
OldCreateOrder = False<br />
Position = poScreenCenter<br />
PixelsPerInch = 96<br />
TextHeight = 13<br />
12.1.7 ENDUNIT APA_DIALOGUNIT.PAS<br />
unit APA_Dialogunit;<br />
interface<br />
uses<br />
- 282 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,<br />
Dialogs, StdCtrls, Buttons, ExtCtrls;<br />
type<br />
TAPA_Dialog = class(TForm)<br />
APA_Text: TLabel;<br />
Panel1: TPanel;<br />
BitBtn1: TBitBtn;<br />
BitBtn2: TBitBtn;<br />
procedure Button1Click(Sender: TObject);<br />
procedure Button2Click(Sender: TObject);<br />
procedure BitBtn1Click(Sender: TObject);<br />
procedure BitBtn2Click(Sender: TObject);<br />
private<br />
{ Private-Deklarationen }<br />
public<br />
{ Public-Deklarationen }<br />
end;<br />
var<br />
APA_Dialog: TAPA_Dialog;<br />
implementation<br />
{$R *.dfm}<br />
procedure TAPA_Dialog.Button1Click(Sender: TObject);<br />
begin<br />
Close;<br />
end;<br />
procedure TAPA_Dialog.Button2Click(Sender: TObject);<br />
begin<br />
Close;<br />
end;<br />
procedure TAPA_Dialog.BitBtn1Click(Sender: TObject);<br />
begin<br />
Modalresult:=mrYes;<br />
end;<br />
procedure TAPA_Dialog.BitBtn2Click(Sender: TObject);<br />
begin<br />
Modalresult:=mrNo;<br />
end;<br />
end.<br />
12.1.8 UNIT APA_GRIDUNIT.DFM<br />
object APA_Grid: TAPA_Grid<br />
Left = 12<br />
Top = 147<br />
Width = 909<br />
Height = 541<br />
Caption = 'APA Grid'<br />
Color = clBtnFace<br />
Font.Charset = DEFAULT_CHARSET<br />
Font.Color = clWindowText<br />
Font.Height = -11<br />
Font.Name = 'MS Sans Serif'<br />
Font.Style = []<br />
Menu = APAGridMenu<br />
OldCreateOrder = False<br />
Position = poScreenCenter<br />
OnShow = FormShow<br />
PixelsPerInch = 96<br />
TextHeight = 13<br />
object APAGrid: TDrawGrid<br />
Left = 1<br />
- 283 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Top = 65<br />
Width = 900<br />
Height = 381<br />
Align = alClient<br />
ColCount = 1<br />
DefaultDrawing = False<br />
FixedCols = 0<br />
RowCount = 1<br />
FixedRows = 0<br />
Options = []<br />
PopupMenu = Gridpopup<br />
TabOrder = 0<br />
OnClick = APAGridClick<br />
OnDblClick = APAGridDblClick<br />
OnDrawCell = APAGridDrawCell<br />
OnMouseDown = APAGridMouseDown<br />
OnMouseMove = APAGridMouseMove<br />
OnMouseWheelDown = APAGridMouseWheelUp<br />
OnMouseWheelUp = APAGridMouseWheelUp<br />
end<br />
object Panel1: TPanel<br />
Left = 0<br />
Top = 0<br />
Width = 901<br />
Height = 41<br />
Align = alTop<br />
TabOrder = 1<br />
OnDblClick = Panel1DblClick<br />
object Button_remove_materialized_cubes: TButton<br />
Left = 8<br />
Top = 8<br />
Width = 151<br />
Height = 25<br />
Caption = 'Remove materialized cubes'<br />
TabOrder = 0<br />
OnClick = Button_remove_materialized_cubesClick<br />
end<br />
object Button_remove_derivatives: TButton<br />
Left = 168<br />
Top = 8<br />
Width = 151<br />
Height = 25<br />
Caption = 'Remove derivatives'<br />
TabOrder = 1<br />
OnClick = Button_remove_derivativesClick<br />
end<br />
object Button_remove_required_cubes: TButton<br />
Left = 328<br />
Top = 8<br />
Width = 151<br />
Height = 25<br />
Caption = 'Remove required cubes'<br />
TabOrder = 2<br />
OnClick = Button_remove_required_cubesClick<br />
end<br />
object Remove_Redundancy: TCheckBox<br />
Left = 488<br />
Top = 8<br />
Width = 145<br />
Height = 23<br />
Caption = 'Remove redundancy'<br />
TabOrder = 3<br />
OnClick = Remove_RedundancyClick<br />
end<br />
object Button1: TButton<br />
Left = 616<br />
Top = 8<br />
Width = 41<br />
Height = 25<br />
Caption = 'Prosser'<br />
TabOrder = 4<br />
Visible = False<br />
OnClick = Button1Click<br />
end<br />
- 284 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
object Button2: TButton<br />
Left = 664<br />
Top = 8<br />
Width = 33<br />
Height = 25<br />
Caption = 'Tom'<br />
TabOrder = 5<br />
Visible = False<br />
OnClick = Button2Click<br />
end<br />
object Button3: TButton<br />
Left = 704<br />
Top = 8<br />
Width = 49<br />
Height = 25<br />
Caption = 'Richtig'<br />
TabOrder = 6<br />
Visible = False<br />
OnClick = Button3Click<br />
end<br />
object Button4: TButton<br />
Left = 760<br />
Top = 8<br />
Width = 49<br />
Height = 25<br />
Caption = 'Richtig2'<br />
TabOrder = 7<br />
Visible = False<br />
OnClick = Button4Click<br />
end<br />
end<br />
object Panel2: TPanel<br />
Left = 0<br />
Top = 446<br />
Width = 901<br />
Height = 41<br />
Align = alBottom<br />
TabOrder = 2<br />
object Button_to_Input_Screen: TButton<br />
Left = 16<br />
Top = 8<br />
Width = 152<br />
Height = 25<br />
Caption = 'Back to Input Screen'<br />
ModalResult = 3<br />
TabOrder = 0<br />
OnClick = Button_to_Input_ScreenClick<br />
end<br />
object Button_to_Selection_Screen: TButton<br />
Left = 176<br />
Top = 8<br />
Width = 152<br />
Height = 25<br />
Caption = 'APA Selection Screen'<br />
ModalResult = 4<br />
TabOrder = 1<br />
OnClick = Button_to_Selection_ScreenClick<br />
end<br />
object Button_to_Main_Menu: TButton<br />
Left = 336<br />
Top = 8<br />
Width = 152<br />
Height = 25<br />
Caption = 'Back to Main Menu'<br />
TabOrder = 2<br />
OnClick = Button_to_Main_MenuClick<br />
end<br />
end<br />
object StatusBar: TStatusBar<br />
Left = 0<br />
Top = 41<br />
Width = 901<br />
Height = 24<br />
Align = alTop<br />
- 285 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Panels = <br />
end<br />
object Panel3: TPanel<br />
Left = 0<br />
Top = 65<br />
Width = 1<br />
Height = 381<br />
Align = alLeft<br />
Caption = 'Panel3'<br />
TabOrder = 4<br />
object ListBox1: TListBox<br />
Left = 1<br />
Top = 42<br />
Width = 998<br />
Height = 338<br />
Align = alClient<br />
ItemHeight = 13<br />
TabOrder = 0<br />
Visible = False<br />
OnDblClick = ListBox1DblClick<br />
end<br />
object Panel4: TPanel<br />
Left = 1<br />
Top = 1<br />
Width = 998<br />
Height = 41<br />
Align = alTop<br />
TabOrder = 1<br />
object Button5: TButton<br />
Left = 14<br />
Top = 8<br />
Width = 75<br />
Height = 25<br />
Caption = 'Close Window'<br />
TabOrder = 0<br />
OnClick = Button5Click<br />
end<br />
end<br />
end<br />
object Gridpopup: TPopupMenu<br />
OnPopup = GridpopupPopup<br />
Left = 248<br />
Top = 224<br />
object NoCubeselected1: TMenuItem<br />
Caption = 'No cube selected'<br />
end<br />
object Redundantcube1: TMenuItem<br />
Caption = 'This is a redundant cube'<br />
Visible = False<br />
end<br />
object N3: TMenuItem<br />
Caption = '-'<br />
end<br />
object Required1: TMenuItem<br />
Caption = 'Required'<br />
object Item1: TMenuItem<br />
OnClick = Item1Click<br />
end<br />
object Item2: TMenuItem<br />
Tag = 1<br />
OnClick = Item1Click<br />
end<br />
object Item3: TMenuItem<br />
Tag = 2<br />
OnClick = Item1Click<br />
end<br />
object Item4: TMenuItem<br />
Tag = 3<br />
OnClick = Item1Click<br />
end<br />
object Item5: TMenuItem<br />
Tag = 4<br />
OnClick = Item1Click<br />
end<br />
- 286 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
object Item6: TMenuItem<br />
Tag = 5<br />
OnClick = Item1Click<br />
end<br />
object Item7: TMenuItem<br />
Tag = 6<br />
OnClick = Item1Click<br />
end<br />
object Item8: TMenuItem<br />
Tag = 7<br />
OnClick = Item1Click<br />
end<br />
object Item9: TMenuItem<br />
Tag = 8<br />
OnClick = Item1Click<br />
end<br />
object Item10: TMenuItem<br />
Tag = 10<br />
OnClick = Item1Click<br />
end<br />
object Item11: TMenuItem<br />
Tag = 10<br />
OnClick = Item1Click<br />
end<br />
object Item12: TMenuItem<br />
Tag = 11<br />
OnClick = Item1Click<br />
end<br />
object Item13: TMenuItem<br />
Tag = 12<br />
OnClick = Item1Click<br />
end<br />
object Item14: TMenuItem<br />
Tag = 13<br />
OnClick = Item1Click<br />
end<br />
object Item15: TMenuItem<br />
Tag = 14<br />
OnClick = Item1Click<br />
end<br />
end<br />
object Notrequired1: TMenuItem<br />
Caption = 'Not required'<br />
GroupIndex = 1<br />
OnClick = Notrequired1Click<br />
end<br />
object Materialize1: TMenuItem<br />
Caption = 'Materialize'<br />
GroupIndex = 1<br />
OnClick = Materialize1Click<br />
end<br />
object Dematerialize1: TMenuItem<br />
Caption = 'Dematerialize'<br />
GroupIndex = 1<br />
OnClick = Dematerialize1Click<br />
end<br />
object N2: TMenuItem<br />
Caption = '-'<br />
GroupIndex = 1<br />
end<br />
object Showderivatives1: TMenuItem<br />
Caption = 'Show derivatives'<br />
GroupIndex = 1<br />
OnClick = Showderivatives1Click<br />
end<br />
object ShowRedundancyfreecube1: TMenuItem<br />
Caption = 'Show redundancy free cube'<br />
GroupIndex = 1<br />
OnClick = ShowRedundancyfreecube1Click<br />
end<br />
object Showpossiblecubes1: TMenuItem<br />
Caption = 'Show possible cubes'<br />
GroupIndex = 1<br />
OnClick = Showpossiblecubes1Click<br />
- 287 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
end<br />
object Removepossiblecubes1: TMenuItem<br />
Caption = 'Remove possible cubes'<br />
GroupIndex = 1<br />
Visible = False<br />
OnClick = Removepossiblecubes1Click<br />
end<br />
object Showdeterministicsolution1: TMenuItem<br />
Caption = 'Show deterministic solution'<br />
GroupIndex = 1<br />
OnClick = Showdeterministicsolution1Click<br />
end<br />
object Removedeterministicsolution1: TMenuItem<br />
Caption = 'Remove deterministic solution'<br />
GroupIndex = 1<br />
OnClick = Removedeterministicsolution1Click<br />
end<br />
object N8: TMenuItem<br />
Caption = '-'<br />
GroupIndex = 1<br />
end<br />
object Heuristics2: TMenuItem<br />
Caption = 'Heuristics'<br />
GroupIndex = 1<br />
object SearchusingThomasAchsheuristic2: TMenuItem<br />
Caption = 'Search using Thomas Achs heuristic'<br />
OnClick = SearchusingThomasAchsheuristic2Click<br />
end<br />
object Alogrithm1: TMenuItem<br />
Caption = 'Alogrithm permutation'<br />
OnClick = Alogrithm1Click<br />
end<br />
object AlgorithmKombination2: TMenuItem<br />
Caption = 'Algorithm combination'<br />
OnClick = AlgorithmKombination2Click<br />
end<br />
end<br />
object BuildCubesinDatabase2: TMenuItem<br />
Caption = 'Build cubes in database for star schema'<br />
GroupIndex = 1<br />
object GenerateCREATESQLStatements1: TMenuItem<br />
Caption = 'Generate CREATE SQL-statements BFT and dimension tables'<br />
OnClick = GenerateCREATESQLStatements1Click<br />
end<br />
end<br />
object Buildcubesindatabaseforfactconstellationschema1: TMenuItem<br />
Caption = 'Build cubes in database for fact constellation schema'<br />
GroupIndex = 1<br />
object GenerateCREATESQLStatementsBFTanddimensiontables1: TMenuItem<br />
Caption = 'Generate CREATE SQL-statements BFT and dimension tables'<br />
OnClick = GenerateCREATESQLStatementsBFTanddimensiontables1Click<br />
end<br />
object GenerateCREATESQLStatementsformaterializedcubes1: TMenuItem<br />
Caption = 'Generate CREATE SQL-statements for materialized cubes'<br />
OnClick = GenerateCREATESQLStatementsformaterializedcubes1Click<br />
end<br />
end<br />
object GetSQLStatementtomaterializethisview1: TMenuItem<br />
Caption = 'Get SQL statement to query this cube'<br />
GroupIndex = 1<br />
object starschema1: TMenuItem<br />
Caption = 'star schema'<br />
OnClick = starschema1Click<br />
end<br />
object factconstellationschema1: TMenuItem<br />
Caption = 'fact constellation schema'<br />
OnClick = factconstellationschema1Click<br />
end<br />
end<br />
object N4: TMenuItem<br />
Caption = '-'<br />
GroupIndex = 1<br />
end<br />
object ShowAnalysewindow2: TMenuItem<br />
- 288 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Caption = 'Show APA analyse window'<br />
GroupIndex = 1<br />
OnClick = ShowAnalysewindow2Click<br />
end<br />
object Showlistbox1: TMenuItem<br />
Caption = 'Show protocoll window'<br />
GroupIndex = 1<br />
OnClick = Showlistbox1Click<br />
end<br />
object N11: TMenuItem<br />
Caption = '-'<br />
GroupIndex = 1<br />
end<br />
object Showcosts1: TMenuItem<br />
Caption = 'Show set random costs and limits left'<br />
GroupIndex = 1<br />
OnClick = Showcosts1Click<br />
end<br />
object ShowSetcalculatedcostsandlimitsleft1: TMenuItem<br />
Caption = 'Show set calculated costs and limits left'<br />
GroupIndex = 1<br />
OnClick = ShowSetcalculatedcostsandlimitsleft1Click<br />
end<br />
object N6: TMenuItem<br />
Caption = '-'<br />
GroupIndex = 1<br />
end<br />
object Getrandomcosts1: TMenuItem<br />
Caption = 'Get random costs'<br />
GroupIndex = 1<br />
object GetbuildBFT2: TMenuItem<br />
Caption = 'Get build from BFT'<br />
GroupIndex = 1<br />
OnClick = GetbuildBFT2Click<br />
end<br />
object GetbuildParent2: TMenuItem<br />
Caption = 'Get build from Parent'<br />
GroupIndex = 1<br />
OnClick = GetbuildParent2Click<br />
end<br />
object N9: TMenuItem<br />
Caption = '-'<br />
GroupIndex = 1<br />
end<br />
object GetQueryBFT2: TMenuItem<br />
Caption = 'Get query from BFT'<br />
GroupIndex = 1<br />
OnClick = GetQueryBFT2Click<br />
end<br />
object GetQueryParent2: TMenuItem<br />
Caption = 'Get Query from Parent'<br />
GroupIndex = 1<br />
OnClick = GetQueryParent2Click<br />
end<br />
end<br />
object Getcalculatedcosts1: TMenuItem<br />
Caption = 'Get calculated costs'<br />
GroupIndex = 1<br />
object GetbuildBFT1: TMenuItem<br />
Caption = 'Get build from BFT'<br />
OnClick = GetbuildBFT1Click<br />
end<br />
object Getbuildfromparent1: TMenuItem<br />
Caption = 'Get build from parent'<br />
OnClick = Getbuildfromparent1Click<br />
end<br />
object N1: TMenuItem<br />
Caption = '-'<br />
end<br />
object GetqueryfromBFT1: TMenuItem<br />
Caption = 'Get query from BFT'<br />
OnClick = GetqueryfromBFT1Click<br />
end<br />
object Getqueryfromparent1: TMenuItem<br />
- 289 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Caption = 'Get query from parent'<br />
OnClick = Getqueryfromparent1Click<br />
end<br />
end<br />
object Getmaterialisationspaceofcube1: TMenuItem<br />
Caption = 'Get materialisation space of cube'<br />
GroupIndex = 1<br />
OnClick = Getmaterialisationspaceofcube1Click<br />
end<br />
object ShowData1: TMenuItem<br />
Caption = 'Show data of cube'<br />
GroupIndex = 1<br />
OnClick = ShowData1Click<br />
end<br />
end<br />
object langbezpopup: TPopupMenu<br />
Left = 104<br />
Top = 272<br />
object langbez1: TMenuItem<br />
Caption = 'langbez'<br />
end<br />
end<br />
object privatmenu: TPopupMenu<br />
Left = 760<br />
Top = 144<br />
object ShowButtons1: TMenuItem<br />
Caption = 'Show Buttons'<br />
OnClick = ShowButtons1Click<br />
end<br />
object ProssernurersterLauf1: TMenuItem<br />
AutoCheck = True<br />
Caption = 'Prosser nur erster Lauf'<br />
Checked = True<br />
end<br />
object Minusnehmen1: TMenuItem<br />
AutoCheck = True<br />
Caption = 'Minus nehmen'<br />
Checked = True<br />
end<br />
object tomohnederivate1: TMenuItem<br />
AutoCheck = True<br />
Caption = 'Tom ohne derivate'<br />
end<br />
object RechneThomas1: TMenuItem<br />
AutoCheck = True<br />
Caption = 'Rechne Thomas'<br />
Checked = True<br />
end<br />
object ClearDatabase1: TMenuItem<br />
Caption = 'Clear Database'<br />
end<br />
object Alwaysspacemaxbeachten1: TMenuItem<br />
AutoCheck = True<br />
Caption = 'Alwaysspacemax beachten'<br />
Checked = True<br />
end<br />
end<br />
object APAGridMenu: TMainMenu<br />
Left = 376<br />
Top = 184<br />
object Actions1: TMenuItem<br />
Caption = 'Actions'<br />
object Removematerializedcubes1: TMenuItem<br />
Caption = 'Remove materialized cubes'<br />
OnClick = Removematerializedcubes1Click<br />
end<br />
object Removederivatives1: TMenuItem<br />
Caption = 'Remove derivatives'<br />
OnClick = Removederivatives1Click<br />
end<br />
object Removerequiredcubes1: TMenuItem<br />
Caption = 'Remove required cubes'<br />
OnClick = Removerequiredcubes1Click<br />
end<br />
- 290 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
end<br />
object Heuristics1: TMenuItem<br />
Caption = 'Heuristics && Algorithms'<br />
object SearchusingProsserheuristic1: TMenuItem<br />
Caption = 'Search using Prosser heuristic'<br />
Visible = False<br />
end<br />
object SearchusingThomasAchsheuristic1: TMenuItem<br />
Caption = 'Search using Thomas Achs heuristic'<br />
OnClick = SearchusingThomasAchsheuristic1Click<br />
end<br />
object Algorithm1: TMenuItem<br />
Caption = 'Algorithm permutation'<br />
OnClick = Algorithm1Click<br />
end<br />
object AlgorithmKombination1: TMenuItem<br />
Caption = 'Algorithm combination'<br />
OnClick = AlgorithmKombination1Click<br />
end<br />
object N7: TMenuItem<br />
Caption = '-'<br />
end<br />
object AnalyseAPA1: TMenuItem<br />
Caption = 'Show APA analyse window'<br />
OnClick = AnalyseAPA1Click<br />
end<br />
object ShowAnalyseWindow1: TMenuItem<br />
Caption = 'Show protocoll window'<br />
OnClick = ShowAnalyseWindow1Click<br />
end<br />
object Showcosts2: TMenuItem<br />
Caption = 'Show Set costs and limits left'<br />
OnClick = Showcosts2Click<br />
end<br />
object Showsetcalculatedcostsandlimitsleft2: TMenuItem<br />
Caption = 'Show set calculated costs and limits left'<br />
end<br />
object N10: TMenuItem<br />
Caption = '-'<br />
end<br />
object Showpossiblecubes2: TMenuItem<br />
Caption = 'Show possible cubes'<br />
OnClick = Showpossiblecubes2Click<br />
end<br />
object Removepossiblecubes2: TMenuItem<br />
Caption = 'Remove possible cubes'<br />
Visible = False<br />
OnClick = Removepossiblecubes2Click<br />
end<br />
object Showdeterministicsolution2: TMenuItem<br />
Caption = 'Show deterministic solution'<br />
OnClick = Showdeterministicsolution2Click<br />
end<br />
object Removedeterministicsolution2: TMenuItem<br />
Caption = 'Remove deterministic solution'<br />
Visible = False<br />
OnClick = Removedeterministicsolution2Click<br />
end<br />
end<br />
object BuildCubesinDatabase1: TMenuItem<br />
Caption = 'Build Cubes in Database'<br />
object GenerateCREATESQLStatementsforStarSchema1: TMenuItem<br />
Caption = 'Generate CREATE SQL-statements for star schema'<br />
object GenerateCREATESQLStatementsBFTanddimensiontables3: TMenuItem<br />
Caption = 'Generate CREATE SQL-statements BFT and dimension tables'<br />
OnClick = GenerateCREATESQLStatementsBFTanddimensiontables3Click<br />
end<br />
end<br />
object GenerateCREATESQLStatementsforfactconstellationschema1: TMenuItem<br />
Caption = 'Generate CREATE SQL-statements for fact constellation schema'<br />
object GenerateCREATESQLStatementsBFTanddimensiontables2: TMenuItem<br />
Caption = 'Generate CREATE SQL-statements BFT and dimension tables'<br />
OnClick = GenerateCREATESQLStatementsBFTanddimensiontables2Click<br />
end<br />
- 291 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
object GenerateCREATESQLStatementsformaterializedcubes2: TMenuItem<br />
Caption = 'Generate CREATE SQL-statements for materialized cubes'<br />
OnClick = GenerateCREATESQLStatementsformaterializedcubes2Click<br />
end<br />
end<br />
end<br />
object Randomcosts1: TMenuItem<br />
Caption = 'Random costs'<br />
object Buildrandomcosts1: TMenuItem<br />
Caption = 'Build random costs'<br />
OnClick = Buildrandomcosts1Click<br />
end<br />
object Showrandomcosts1: TMenuItem<br />
Caption = 'Show random costs'<br />
OnClick = Showrandomcosts1Click<br />
end<br />
object Restrictedcosts1: TMenuItem<br />
AutoCheck = True<br />
Caption = 'Restricted costs'<br />
Checked = True<br />
OnClick = Restrictedcosts1Click<br />
end<br />
end<br />
object Settings1: TMenuItem<br />
Caption = 'Settings'<br />
object Userandomcosts1: TMenuItem<br />
AutoCheck = True<br />
Caption = 'Use random costs'<br />
Checked = True<br />
end<br />
object Removeredundancy1: TMenuItem<br />
Caption = 'Remove redundancy'<br />
OnClick = Removeredundancy1Click<br />
end<br />
object N5: TMenuItem<br />
Caption = '-'<br />
end<br />
object Parameter1: TMenuItem<br />
Caption = 'Parameters'<br />
OnClick = Parameter1Click<br />
end<br />
object Options1: TMenuItem<br />
Caption = 'Options'<br />
OnClick = Options1Click<br />
end<br />
end<br />
object Help1: TMenuItem<br />
Caption = 'Help'<br />
object HelpforAPAGridScreen1: TMenuItem<br />
Caption = 'Help for APA Grid Screen'<br />
OnClick = HelpforAPAGridScreen1Click<br />
end<br />
object HelpforAPAProgram1: TMenuItem<br />
Caption = 'Help for APA Program'<br />
OnClick = HelpforAPAProgram1Click<br />
end<br />
end<br />
end<br />
end<br />
12.1.9 UNIT APA_GRIDUNIT.PAS<br />
unit APA_Gridunit;<br />
interface<br />
uses<br />
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,<br />
Dialogs, ComCtrls, Menus, StdCtrls, ExtCtrls, Grids, Math;<br />
type<br />
TAPA_Grid = class(TForm)<br />
- 292 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
APAGrid: TDrawGrid;<br />
Panel1: TPanel;<br />
Button_remove_materialized_cubes: TButton;<br />
Button_remove_derivatives: TButton;<br />
Button_remove_required_cubes: TButton;<br />
Remove_Redundancy: TCheckBox;<br />
Button1: TButton;<br />
Button2: TButton;<br />
Panel2: TPanel;<br />
Button_to_Input_Screen: TButton;<br />
Button_to_Selection_Screen: TButton;<br />
Button_to_Main_Menu: TButton;<br />
Gridpopup: TPopupMenu;<br />
Redundantcube1: TMenuItem;<br />
N3: TMenuItem;<br />
Required1: TMenuItem;<br />
Item1: TMenuItem;<br />
Item2: TMenuItem;<br />
Item3: TMenuItem;<br />
Notrequired1: TMenuItem;<br />
Materialize1: TMenuItem;<br />
Dematerialize1: TMenuItem;<br />
N2: TMenuItem;<br />
Showderivatives1: TMenuItem;<br />
ShowRedundancyfreecube1: TMenuItem;<br />
Showlistbox1: TMenuItem;<br />
langbezpopup: TPopupMenu;<br />
langbez1: TMenuItem;<br />
privatmenu: TPopupMenu;<br />
ProssernurersterLauf1: TMenuItem;<br />
StatusBar: TStatusBar;<br />
Minusnehmen1: TMenuItem;<br />
Item4: TMenuItem;<br />
Item5: TMenuItem;<br />
Item6: TMenuItem;<br />
Item7: TMenuItem;<br />
Item8: TMenuItem;<br />
Item9: TMenuItem;<br />
Item10: TMenuItem;<br />
Item11: TMenuItem;<br />
Item12: TMenuItem;<br />
Item13: TMenuItem;<br />
Item14: TMenuItem;<br />
Item15: TMenuItem;<br />
APAGridMenu: TMainMenu;<br />
Actions1: TMenuItem;<br />
Settings1: TMenuItem;<br />
Removematerializedcubes1: TMenuItem;<br />
Removederivatives1: TMenuItem;<br />
Removerequiredcubes1: TMenuItem;<br />
Userandomcosts1: TMenuItem;<br />
Removeredundancy1: TMenuItem;<br />
BuildCubesinDatabase1: TMenuItem;<br />
Heuristics1: TMenuItem;<br />
SearchusingProsserheuristic1: TMenuItem;<br />
SearchusingThomasAchsheuristic1: TMenuItem;<br />
tomohnederivate1: TMenuItem;<br />
Button3: TButton;<br />
RechneThomas1: TMenuItem;<br />
Algorithm1: TMenuItem;<br />
Heuristics2: TMenuItem;<br />
SearchusingThomasAchsheuristic2: TMenuItem;<br />
Alogrithm1: TMenuItem;<br />
N4: TMenuItem;<br />
BuildCubesinDatabase2: TMenuItem;<br />
GenerateCREATESQLStatements1: TMenuItem;<br />
NoCubeselected1: TMenuItem;<br />
N5: TMenuItem;<br />
Parameter1: TMenuItem;<br />
Showcosts1: TMenuItem;<br />
Button4: TButton;<br />
Options1: TMenuItem;<br />
N6: TMenuItem;<br />
ShowData1: TMenuItem;<br />
- 293 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Panel3: TPanel;<br />
ListBox1: TListBox;<br />
Panel4: TPanel;<br />
Button5: TButton;<br />
AlgorithmKombination1: TMenuItem;<br />
AlgorithmKombination2: TMenuItem;<br />
Getrandomcosts1: TMenuItem;<br />
GetbuildBFT2: TMenuItem;<br />
GetbuildParent2: TMenuItem;<br />
N9: TMenuItem;<br />
GetQueryBFT2: TMenuItem;<br />
GetQueryParent2: TMenuItem;<br />
ClearDatabase1: TMenuItem;<br />
Randomcosts1: TMenuItem;<br />
Buildrandomcosts1: TMenuItem;<br />
Showrandomcosts1: TMenuItem;<br />
N7: TMenuItem;<br />
Showcosts2: TMenuItem;<br />
N8: TMenuItem;<br />
ShowAnalyseWindow1: TMenuItem;<br />
AnalyseAPA1: TMenuItem;<br />
ShowAnalysewindow2: TMenuItem;<br />
Showpossiblecubes1: TMenuItem;<br />
Removepossiblecubes1: TMenuItem;<br />
Showpossiblecubes2: TMenuItem;<br />
Removepossiblecubes2: TMenuItem;<br />
Getmaterialisationspaceofcube1: TMenuItem;<br />
ShowButtons1: TMenuItem;<br />
GetSQLStatementtomaterializethisview1: TMenuItem;<br />
Getcalculatedcosts1: TMenuItem;<br />
GetbuildBFT1: TMenuItem;<br />
Getbuildfromparent1: TMenuItem;<br />
N1: TMenuItem;<br />
GetqueryfromBFT1: TMenuItem;<br />
Getqueryfromparent1: TMenuItem;<br />
ShowSetcalculatedcostsandlimitsleft1: TMenuItem;<br />
Showsetcalculatedcostsandlimitsleft2: TMenuItem;<br />
N10: TMenuItem;<br />
Restrictedcosts1: TMenuItem;<br />
Showdeterministicsolution1: TMenuItem;<br />
Removedeterministicsolution1: TMenuItem;<br />
Showdeterministicsolution2: TMenuItem;<br />
Removedeterministicsolution2: TMenuItem;<br />
Buildcubesindatabaseforfactconstellationschema1: TMenuItem;<br />
GenerateCREATESQLStatementsformaterializedcubes1: TMenuItem;<br />
GenerateCREATESQLStatementsBFTanddimensiontables1: TMenuItem;<br />
GenerateCREATESQLStatementsforStarSchema1: TMenuItem;<br />
GenerateCREATESQLStatementsforfactconstellationschema1: TMenuItem;<br />
GenerateCREATESQLStatementsformaterializedcubes2: TMenuItem;<br />
GenerateCREATESQLStatementsBFTanddimensiontables2: TMenuItem;<br />
GenerateCREATESQLStatementsBFTanddimensiontables3: TMenuItem;<br />
Alwaysspacemaxbeachten1: TMenuItem;<br />
Help1: TMenuItem;<br />
HelpforAPAGridScreen1: TMenuItem;<br />
N11: TMenuItem;<br />
HelpforAPAProgram1: TMenuItem;<br />
starschema1: TMenuItem;<br />
factconstellationschema1: TMenuItem;<br />
procedure generate();<br />
procedure Erzeugungsbericht1Click(Sender: TObject);<br />
procedure APAGridDrawCell(Sender: TObject; ACol, ARow: Integer;<br />
Rect: TRect; State: TGridDrawState);<br />
procedure APAGridMouseMove(Sender: TObject; Shift: TShiftState; X,<br />
Y: Integer);<br />
procedure Showlistbox1Click(Sender: TObject);<br />
procedure Materialize1Click(Sender: TObject);<br />
procedure Notrequired1Click(Sender: TObject);<br />
procedure Dematerialize1Click(Sender: TObject);<br />
procedure Showderivatives1Click(Sender: TObject);<br />
procedure APAGridDblClick(Sender: TObject);<br />
procedure APAGridMouseDown(Sender: TObject; Button: TMouseButton;<br />
Shift: TShiftState; X, Y: Integer);<br />
procedure Button_to_Input_ScreenClick(Sender: TObject);<br />
procedure Button_to_Selection_ScreenClick(Sender: TObject);<br />
- 294 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
procedure Button_to_Main_MenuClick(Sender: TObject);<br />
procedure Remove_RedundancyClick(Sender: TObject);<br />
procedure ShowRedundancyfreecube1Click(Sender: TObject);<br />
procedure Button_remove_required_cubesClick(Sender: TObject);<br />
procedure Button_remove_derivativesClick(Sender: TObject);<br />
procedure Button_remove_materialized_cubesClick(Sender: TObject);<br />
procedure ListBox1DblClick(Sender: TObject);<br />
procedure FormShow(Sender: TObject);<br />
procedure bezeichnungenholen();<br />
procedure materialzeichnen;<br />
function getbuild(vonspalte,vonzeile,zuspalte,zuzeile:longint):Extended;<br />
function getquery(vonspalte,vonzeile,zuspalte,zuzeile:longint):Extended;<br />
function auffuellen(st:string;anzahl:longint):string;<br />
function gettupel(aktspalte,aktzeile:longint):Extended;<br />
function<br />
getgrouptupel(parentspalte,parentzeile,aktspalte,aktzeile:longint):Extended;<br />
function deltaBftW(aktspalte,aktzeile:longint;Query:boolean):Extended;<br />
function deltaVW(spalte,zeile,aktspalte,aktzeile:longint;query:boolean):Extended;<br />
function GetMinDerivatOfSpalte(aktspalte,aktzeile:longint;Query:boolean):longint;<br />
function GetMinDerivatOfZeile(aktspalte,aktzeile:longint;Query:boolean):longint;<br />
procedure berechneProsser();<br />
procedure Button1Click(Sender: TObject);<br />
function isderivat(spaltev,zeilev,spaltew,zeilew:longint):boolean;<br />
procedure Item1Click(Sender: TObject);<br />
procedure Button2Click(Sender: TObject);<br />
procedure APAGridClick(Sender: TObject);<br />
procedure GridpopupPopup(Sender: TObject);<br />
procedure Removematerializedcubes1Click(Sender: TObject);<br />
procedure Removederivatives1Click(Sender: TObject);<br />
procedure Removerequiredcubes1Click(Sender: TObject);<br />
procedure Removeredundancy1Click(Sender: TObject);<br />
procedure Button3Click(Sender: TObject);<br />
procedure Algorithm1Click(Sender: TObject);<br />
procedure SearchusingThomasAchsheuristic2Click(Sender: TObject);<br />
procedure Alogrithm1Click(Sender: TObject);<br />
procedure Parameter1Click(Sender: TObject);<br />
function<br />
berechneKostenGesamt(MatCubes,ReqCubes:TStringList;Nullstellen:boolean):Extended;<br />
procedure Showcosts1Click(Sender: TObject);<br />
function GetRightOrdertom(Listecubes:TStringList):TStringList;<br />
procedure Button4Click(Sender: TObject);<br />
procedure Options1Click(Sender: TObject);<br />
procedure ShowData1Click(Sender: TObject);<br />
procedure Button5Click(Sender: TObject);<br />
procedure AlgorithmKombination1Click(Sender: TObject);<br />
procedure AlgorithmKombination2Click(Sender: TObject);<br />
procedure GetbuildBFT2Click(Sender: TObject);<br />
procedure GetbuildParent2Click(Sender: TObject);<br />
procedure GetQueryBFT2Click(Sender: TObject);<br />
procedure GetQueryParent2Click(Sender: TObject);<br />
procedure GenerateCREATESQLStatements1Click(Sender: TObject);<br />
procedure SearchusingThomasAchsheuristic1Click(Sender: TObject);<br />
procedure Panel1DblClick(Sender: TObject);<br />
procedure Buildrandomcosts1Click(Sender: TObject);<br />
procedure Showrandomcosts1Click(Sender: TObject);<br />
procedure Showcosts2Click(Sender: TObject);<br />
procedure ShowAnalyseWindow1Click(Sender: TObject);<br />
procedure AnalyseAPA1Click(Sender: TObject);<br />
procedure ShowAnalysewindow2Click(Sender: TObject);<br />
procedure Showpossiblecubes1Click(Sender: TObject);<br />
procedure Removepossiblecubes1Click(Sender: TObject);<br />
procedure Showpossiblecubes2Click(Sender: TObject);<br />
procedure Removepossiblecubes2Click(Sender: TObject);<br />
procedure Getmaterialisationspaceofcube1Click(Sender: TObject);<br />
procedure ShowButtons1Click(Sender: TObject);<br />
procedure GetbuildBFT1Click(Sender: TObject);<br />
procedure GetqueryfromBFT1Click(Sender: TObject);<br />
procedure Getbuildfromparent1Click(Sender: TObject);<br />
procedure Getqueryfromparent1Click(Sender: TObject);<br />
procedure ShowSetcalculatedcostsandlimitsleft1Click(Sender: TObject);<br />
procedure Restrictedcosts1Click(Sender: TObject);<br />
procedure Showdeterministicsolution2Click(Sender: TObject);<br />
procedure Showdeterministicsolution1Click(Sender: TObject);<br />
procedure Removedeterministicsolution1Click(Sender: TObject);<br />
- 295 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
procedure Removedeterministicsolution2Click(Sender: TObject);<br />
procedure GenerateCREATESQLStatementsBFTanddimensiontables3Click(<br />
Sender: TObject);<br />
procedure GenerateCREATESQLStatementsformaterializedcubes2Click(<br />
Sender: TObject);<br />
procedure GenerateCREATESQLStatementsBFTanddimensiontables2Click(<br />
Sender: TObject);<br />
procedure GenerateCREATESQLStatementsBFTanddimensiontables1Click(<br />
Sender: TObject);<br />
procedure GenerateCREATESQLStatementsformaterializedcubes1Click(<br />
Sender: TObject);<br />
procedure APAGridMouseWheelUp(Sender: TObject; Shift: TShiftState;<br />
MousePos: TPoint; var Handled: Boolean);<br />
procedure HelpforAPAGridScreen1Click(Sender: TObject);<br />
procedure HelpforAPAProgram1Click(Sender: TObject);<br />
procedure factconstellationschema1Click(Sender: TObject);<br />
procedure starschema1Click(Sender: TObject);<br />
private<br />
{ Private-Deklarationen }<br />
public<br />
{ Public-Deklarationen }<br />
end;<br />
type<br />
TAPAField = record<br />
linieoben:boolean;<br />
linieunten:boolean;<br />
linierechts:boolean;<br />
linielinks:boolean;<br />
dickoben:boolean;<br />
dickunten:boolean;<br />
dickrechts:boolean;<br />
dicklinks:boolean;<br />
farbe:TColor;<br />
interessant:boolean;<br />
materalisieren:boolean;<br />
matcount:longint;//Gibt die Reihenfolge der Materialisierung an<br />
derivative:boolean;<br />
langbez:array of String;<br />
kurzbez:String;<br />
screenbez:String;<br />
counthier:longint;//Gibt die neue Hierarchiestufe an<br />
countdimension:longint;//Gibt die Dimension an, welche erhöht wird<br />
zeile:longint;<br />
spalte:longint;<br />
gewicht:Extended;<br />
gewichtlevel:longint;<br />
value:Extended;//Gibt den Speicherwert an<br />
value2:Extended;//Gibt den zweiten Speicherwert an<br />
hierstufe:array of longint; //Gibt die aktuelle Hierarchiestufe jeder Dimension an<br />
flag:Extended;<br />
end;<br />
var<br />
APA_Grid: TAPA_Grid;<br />
APA: array of array of TAPAField;<br />
{Das Gitter}<br />
dk: array of array of String;<br />
{Alle Kurzbezeichungen der Dimension x und der Hierarchie y}<br />
dl: array of array of String;<br />
{Alle Langbezeichnungen der Dimension x und der Hierarchie y}<br />
countdaten: array of array of longint;<br />
{Die Anzahl der Datensätze der Dimension x und der Hierarchie y}<br />
anzd:longint;<br />
{Anzahl der Dimensionen}<br />
anzh: array of longint;<br />
{Anzahl der Hierarchiestufen der Dimension x}<br />
- 296 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
dimbez: array of String;<br />
{Bezeichnung der Dimension x}<br />
zellezeile:longint;<br />
{Wert für die aktuelle Spalte im Gitter}<br />
zellespalte:longint;<br />
{Wert für die aktuelle Zeile im Gitter}<br />
anzzeilen:longint;<br />
{Anzahl Zeilen des APA gesamt}<br />
anzspalten:longint;<br />
{Anzahl der Spalten des APA gesamt}<br />
maxh:longint;<br />
{Maximale Anzahl der Hierarchiestufen einer Dimension}<br />
{Gibt die Aktuellen Bildschirmkoordinaten der Mouse an}<br />
aktx:longint;<br />
akty:longint;<br />
{Gibt die Zelle an, welche zuletzt angeklickt wurde}<br />
klickspalte:longint= -1;<br />
klickzeile:longint= -1;<br />
gotoSelection:boolean=false;<br />
gotoInput:boolean=false;<br />
{Gibt an, ob die Bezeichnungen ok sind}<br />
bezeichnungenkontrolliert:boolean;<br />
matcount:longint=0;//Gibt den aktuellen Materialisierungszähler an<br />
permutation:boolean=true;<br />
implementation<br />
uses APA_Selectionunit, APA_Parameterunit, APA_Input_Screenunit,<br />
APA_Applicationunit, APA_Processunit, APA_Sqlunit, APA_Keyunit,<br />
APA_Dialogunit, APA_Optionsunit, APA_Show_costsunit, APA_Helpunit;<br />
{$R *.dfm}<br />
type Memorycubestype=<br />
record<br />
nr:longint;<br />
spalte:longint;<br />
zeile:longint;<br />
end;<br />
var Memorywuerfel: TStringList; //Die Liste der ausgewählten Würfel//<br />
MerkeListe:array of longint;<br />
spaceleft, spaceleftfirstcubes,timeleft:Extended;<br />
Memorycubes,MemoryReqCubes:array of Memorycubestype;<br />
MemoryReqCubescount:longint;<br />
function TAPA_Grid.isderivat(spaltev,zeilev,spaltew,zeilew:longint):boolean;<br />
var counter:longint;<br />
derivat:boolean;<br />
begin;<br />
//Überprüfe, ob w ein Derivat von v ist:<br />
//Wenn alle Dimensionen von v eine Hierarchiestufe gleich oder höher<br />
//als w haben > dann ist es ein Derivat.<br />
derivat:=false;<br />
try<br />
//Standardmäßig ist es ein Derivat<br />
derivat:=true;<br />
for counter:=0 to anzd-1 do begin<br />
//Sollte eine Dimension von w eine geringere Hierachie<br />
//als v haben, kann w nicht aus v errechnet werden<br />
- 297 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if APA[spaltew,zeilew].hierstufe[counter]
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if Eingabe.Items.GetFirstNodenil then begin<br />
{Wenn überhaupt etwas eingetragen ist dann ...}<br />
dimcounter:=0;<br />
CurItem := Eingabe.Items.GetFirstNode;<br />
while (CurItem nil)and(abort=false) do<br />
begin<br />
anzh[dimcounter]:=CurItem.Count;<br />
dimbez[dimcounter]:=CurItem.Text;<br />
APA_Grid.ListBox1.Items.Add('****************************');<br />
APA_Grid.ListBox1.Items.Add('Die Dimension '+dimbez[dimcounter]+'<br />
'+inttostr(dimcounter)+' hat '+inttostr(anzh[dimcounter])+' Hierarchiestufen');<br />
APA_Grid.ListBox1.Items.Add('Anzahl der Kurzbezeichnungen dieser Dimension festlegen<br />
mit '+inttostr(anzh[dimcounter]));<br />
{Anzahl der Kurzbezeichnungen dieser Dimension festlegen}<br />
setlength(dk[dimcounter],anzh[dimcounter]);<br />
APA_Grid.ListBox1.Items.Add('Anzahl der Langbezeichnungen dieser Dimension festlegen<br />
mit '+inttostr(anzh[dimcounter]));<br />
{Anzahl der Langbezeichnungen dieser Dimension festlegen}<br />
setlength(dl[dimcounter],anzh[dimcounter]);<br />
APA_Grid.ListBox1.Items.Add('Anzahl der Countdaten dieser Dimension festlegen mit<br />
'+inttostr(anzh[dimcounter]));<br />
{Anzahl der Langbezeichnungen dieser Dimension festlegen}<br />
setlength(countdaten[dimcounter],anzh[dimcounter]);<br />
CurItem:=CurItem.GetNext;<br />
counter:=0;merkecount:=0;<br />
while (CurItem nil)and(CurItem.HasChildren=false)and(abort=false) do<br />
begin<br />
{Eintragen der Kurzbezeichnung}<br />
dk[dimcounter,counter]:=<br />
copy(CurItem.Text,1,pos('//',CurItem.Text)-1);<br />
APA_Grid.ListBox1.Items.Add('dk['+inttostr(dimcounter)+','+inttostr(counter)+']<br />
Kurzbezeichnung '+dk[dimcounter,counter]+' eingetragen');<br />
{Eintragen der Langbezeichnung}<br />
dl[dimcounter,counter]:=<br />
copy(CurItem.Text,pos('//',CurItem.Text)+2,pos('::',CurItem.Text)-<br />
(pos('//',CurItem.Text)+2));<br />
APA_Grid.ListBox1.Items.Add('dl['+inttostr(dimcounter)+','+inttostr(counter)+']<br />
Langbezeichnung '+dl[dimcounter,counter]+' eingetragen');<br />
{Eintragen der Countdaten}<br />
countdaten[dimcounter,counter]:=<br />
strtoint(copy(CurItem.Text,pos('::',CurItem.Text)+2,255));<br />
APA_Grid.ListBox1.Items.Add('countdaten['+inttostr(dimcounter)+','+inttostr(counte<br />
r)+'] Countdaten '+inttostr(countdaten[dimcounter,counter])+' eingetragen');<br />
{Feststellen, ob die Anzahl der Datensätze größer ist als der Vorgänger}<br />
if (countdaten[dimcounter,counter]>merkecount)and(merkecount0) then begin;<br />
Showmessage('Error generating APA. Count of records in hierarchy<br />
'+dk[dimcounter,counter]+' is larger than lower hierarchy. Abort Generation!');<br />
abort:=true;<br />
end;<br />
{Setzen von merkecount}<br />
merkecount:=countdaten[dimcounter,counter];<br />
CurItem:=CurItem.GetNext;<br />
counter:=counter+1;<br />
end;<br />
dimcounter:=dimcounter+1;<br />
end;<br />
end;<br />
- 299 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
{********* Anzahl der Dimensionen feststellen ENDE}<br />
if abort=false then bezeichnungenkontrolliert:=true;<br />
end;<br />
end;<br />
function wuerfelvergleich (spalte,zeile:longint; akth:array of longint):boolean;<br />
var derivat: array of longint;<br />
g,x2:longint;<br />
merk:boolean;<br />
begin<br />
//Bestimme die Hierarchiestufen der Dimensionen des materialisierten Elements<br />
derivat:=nil;<br />
setlength(derivat,anzd);<br />
//Starte in Hierarchiestufe 0<br />
for x2:=0 to anzd-1 do derivat[x2]:=0;<br />
//Belege akthier mit der maximalen Hierarchiestufe jeder Dimension<br />
for x2:=0 to spalte do<br />
derivat[APA[x2,zeile].countdimension]:=APA[x2,zeile].counthier;<br />
//Überprüfe, ob keine Hierarchiestufe der Dimension der aktuellen Zelle<br />
// kleiner als die Hierarchiestufe der Dimension der materialisierten Würfel sind//<br />
merk:=true;<br />
for g:=0 to anzd-1 do begin<br />
if (derivat[g]=0)and(ende=false) do begin<br />
if wuerfelvergleich(aktspalte,aktzeile, akth)=false then begin<br />
//Wenn kein Derivat<br />
ende:=true;<br />
//Spalte links vom Derivat mach eine rechte Linie<br />
APA[aktspalte,aktzeile].linierechts:=true;<br />
- 300 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
aktspalte:=aktspalte+1;<br />
//im letzten Derivat mach eine linke Linie<br />
APA[aktspalte,aktzeile].linielinks:=true;<br />
end else aktspalte:=aktspalte-1;<br />
end; {von while}<br />
//Wenn die erste Zeile durchlaufen und ende ist immer noch false dann<br />
// starte in der ersten Spalte von links<br />
if (ende=false) then begin;<br />
aktspalte:=0;<br />
APA[aktspalte,aktzeile].linielinks:=true;<br />
end;<br />
//Der Cursor wandert zwischen den Zellen durch das Gitter.<br />
// Die Positionsmarke des Cursors befindet sich immer in der linken<br />
// unteren Ecke des Feldes.<br />
//Das Programm kontrolliert die Zellen unterhalb.<br />
// Feld[0] ist das Feld diagonal links untern.<br />
// Feld[1] ist das Feld unmittelbar darunter.<br />
//Setze beide Felder auf false<br />
feld:=nil;<br />
setlength(feld,2);<br />
feld[0]:=false;<br />
feld[1]:=false;<br />
while(aktzeile
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
procedure TAPA_Grid.materialzeichnen;<br />
var spalte,zeile:longint;<br />
ende:boolean;<br />
begin<br />
//Diese Methode zeichnet alle zu materialisierenden Würfel und zieht anschließend<br />
// die dicke rote Begrenzungsinie.<br />
//Alle Linien löschen<br />
for spalte:= 0 to anzspalten-1 do begin<br />
for zeile:=0 to anzzeilen-1 do begin<br />
APA[spalte,zeile].linieoben:=false;<br />
APA[spalte,zeile].linieunten:=false;<br />
APA[spalte,zeile].linielinks:=false;<br />
APA[spalte,zeile].linierechts:=false;<br />
APA[spalte,zeile].derivative:=false;<br />
APA[spalte,zeile].dickoben:=false;<br />
APA[spalte,zeile].dickunten:=false;<br />
APA[spalte,zeile].dicklinks:=false;<br />
APA[spalte,zeile].dickrechts:=false;<br />
end; //Ende von Zeilen<br />
end; //Ende von Spalten<br />
// Materialisiere alle Würfel, wo materailize = true<br />
for spalte:= 0 to anzspalten-1 do begin<br />
for zeile:=0 to anzzeilen-1 do begin<br />
if APA[spalte,zeile].materalisieren=true then begin<br />
markierederivative(spalte,zeile);<br />
end;<br />
end; //Ende von Zeilen<br />
end; //Ende von Spalten<br />
//Aussenlinie generieren<br />
for zeile:= 0 to anzzeilen-1 do begin<br />
ende:=false;<br />
for spalte:=0 to anzspalten-1 do begin<br />
if ende=false then begin<br />
//Einfärben<br />
if APA[spalte,zeile].linielinks=true then begin<br />
//Line links<br />
APA[spalte,zeile].dicklinks:=true;<br />
ende:=true;<br />
end else begin<br />
//Line links links<br />
APA[spalte,zeile].dickoben:=APA[spalte,zeile].linieoben;<br />
APA[spalte,zeile].dickunten:=APA[spalte,zeile].linieunten;<br />
APA[spalte,zeile].dicklinks:=APA[spalte,zeile].linielinks;<br />
APA[spalte,zeile].dickrechts:=APA[spalte,zeile].linierechts;<br />
//Wenn die unter Zeile nicht die letzte ist ziehe auch die<br />
//untere Linie nach<br />
if zeile0) then<br />
APA[spalte,zeile-1].dickunten:=APA[spalte,zeile-1].linieunten;<br />
- 302 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
end;<br />
end;<br />
end; //Ende von Zeilen<br />
end; //Ende von Spalten<br />
//Alle Linien löschen<br />
for spalte:= 0 to anzspalten-1 do begin<br />
end;<br />
for zeile:=0 to anzzeilen-1 do begin<br />
APA[spalte,zeile].linieoben:=false;<br />
APA[spalte,zeile].linieunten:=false;<br />
APA[spalte,zeile].linielinks:=false;<br />
APA[spalte,zeile].linierechts:=false;<br />
APA[spalte,zeile].derivative:=false;<br />
end; //Ende von Zeilen<br />
end; //Ende von Spalten<br />
procedure ausfuellen(tozeile, tospalte, fromzeile,fromspalte, zeilemax:longint;<br />
nachunten:boolean);<br />
var zeile:longint;<br />
begin<br />
zeile:=tozeile;<br />
if (nachunten=true) then begin<br />
while (zeilezeilemax) do begin<br />
if (APA[tospalte,zeile].Screenbez='') then begin<br />
APA[tospalte,zeile].Screenbez:=APA[fromspalte,fromzeile].Screenbez;<br />
APA[tospalte,zeile].countdimension:=APA[fromspalte,fromzeile].countdimension;<br />
APA[tospalte,zeile].counthier:=APA[fromspalte,fromzeile].counthier;<br />
APA[tospalte,zeile].gewicht:=0;<br />
APA[tospalte,zeile].gewichtlevel:=-1;<br />
end;<br />
zeile:=zeile-1;<br />
end;<br />
end;<br />
end;<br />
procedure zellenkop(fromx1,fromy1,fromx2,fromy2,tox,toy:longint; oben,mitfarbe:boolean);<br />
var x,y:longint;<br />
begin<br />
{Kopiere die Zellen fromx1,formy1 bis fromx2,fromy2 auf die Zelle tox,toy und folgende}<br />
if (oben=false) then toy:=toy-abs(fromy1-fromy2);<br />
for x:=min(fromx1,fromx2) to max(fromx1,fromx2) do begin<br />
for y:= min(fromy1,fromy2) to max(fromy1,fromy2) do begin<br />
- 303 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
end;<br />
end;<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
APA[tox-min(fromx1,fromx2)+x,toymin(fromy1,fromy2)+y].Screenbez:=APA[x,y].Screenbez;<br />
if mitfarbe=true then<br />
APA[tox-min(fromx1,fromx2)+x,toy-min(fromy1,fromy2)+y].farbe:=APA[x,y].farbe;<br />
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;<br />
APA[tox-min(fromx1,fromx2)+x,toy-min(fromy1,fromy2)+y].gewicht:=0;<br />
APA[tox-min(fromx1,fromx2)+x,toy-min(fromy1,fromy2)+y].gewichtlevel:=-1;<br />
end;<br />
procedure calculatecolumnscount;<br />
var counter:longint;<br />
begin<br />
{Diese Procedure berechnet die Anzahl der Spalten des gesamten APA}<br />
anzspalten:=0;<br />
for counter:=0 to anzd-1 do anzspalten:=anzspalten+(anzh[counter]-1);<br />
APA_Grid.ListBox1.Items.Add('Anzahl der Spalten des APAs berechnet mit<br />
'+inttostr(anzspalten));<br />
end;<br />
procedure calculaterowcount;<br />
var counter:longint;<br />
begin<br />
{Diese Procedure berechnet die Anzahl der Zeilen des gesamten APA}<br />
anzzeilen:=1;<br />
for counter:=0 to anzd-1 do begin;<br />
if (anzh[counter]0) then anzzeilen:=anzzeilen*anzh[counter];<br />
if (maxh
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
end;<br />
end;<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
end;<br />
APA[x,zeile].kurzbez:=s;<br />
//Kurzbezeichnung generieren ENDE<br />
//Langbezeichnung generieren<br />
APA[x,zeile].langbez:=nil;<br />
setlength(APA[x,zeile].langbez,anzd);<br />
//Hierarchiestufenausprägungen generieren<br />
APA[x,zeile].hierstufe:=nil;<br />
setlength(APA[x,zeile].hierstufe,anzd);<br />
for z:=0 to anzd-1 do begin<br />
APA[x,zeile].langbez[z]:=dimbez[z]+':'+dl[z,akthier[z]];<br />
APA[x,zeile].hierstufe[z]:=akthier[z];<br />
end;<br />
//Langbezeichnung generieren ENDE<br />
end;<br />
procedure TAPA_Grid.generate;<br />
var zeile,spalte:longint;<br />
var feld,dimcounter,hiercounter, counter:longint;<br />
var aktuelledim,aktuellespalte,aktuellezeile,anzkop:longint;<br />
begin<br />
{APA erzeugen}<br />
APA:=nil;<br />
setlength(APA,anzspalten,anzzeilen);<br />
{APA mit Werten füllen}<br />
for zeile:=0 to anzzeilen-1 do begin<br />
for spalte:=0 to anzspalten-1 do begin<br />
APA[spalte,zeile].zeile:=zeile;<br />
APA[spalte,zeile].spalte:=spalte;<br />
APA[spalte,zeile].linieoben:=false;<br />
APA[spalte,zeile].linieunten:=false;<br />
APA[spalte,zeile].linielinks:=false;<br />
APA[spalte,zeile].linierechts:=false;<br />
APA[spalte,zeile].dickoben:=false;<br />
APA[spalte,zeile].dickunten:=false;<br />
APA[spalte,zeile].dicklinks:=false;<br />
APA[spalte,zeile].dickrechts:=false;<br />
APA[spalte,zeile].farbe:=clWhite;<br />
APA[spalte,zeile].interessant:=false;<br />
APA[spalte,zeile].materalisieren:=false;<br />
APA[spalte,zeile].derivative:=false;<br />
APA[spalte,zeile].Screenbez:='';<br />
APA[spalte,zeile].kurzbez:='';<br />
end;<br />
end;<br />
{Erste Zeile erzeugen}<br />
feld:=0;<br />
for dimcounter:=0 to anzd-1 do begin<br />
for hiercounter:=1 to anzh[dimcounter]-1 do begin<br />
APA[feld,0].Screenbez:=dk[dimcounter,hiercounter];<br />
APA[feld,0].farbe:=clYellow;<br />
APA[feld,0].counthier:=hiercounter;<br />
APA[feld,0].countdimension:=dimcounter;<br />
APA[feld,0].gewicht:=0;<br />
APA[feld,0].gewichtlevel:=0;<br />
end;<br />
end;<br />
feld:=feld+1;<br />
- 305 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
{Kopieren der redundanzfreien Zellen des APA}<br />
aktuelledim:=anzd-1;<br />
aktuellespalte:=anzspalten-(anzh[aktuelledim]-1);<br />
aktuellezeile:=0;<br />
while (aktuellespalte>0) do begin<br />
{Kopiere Block Beginn}<br />
anzkop:=0;<br />
while (anzkop
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
NewRect.Left:=Rect.left;<br />
NewRect.Right:=Rect.left+13;<br />
NewRect.Top:=Rect.Bottom-13;<br />
NewRect.Bottom:=Rect.Bottom;<br />
APAGrid.Canvas.Brush.Color:=clBlack;<br />
APAGrid.Canvas.FillRect(NewRect);<br />
APAGrid.Canvas.Font.Color:=clWhite;<br />
APAGrid.Canvas.Font.Size:=4;<br />
APAGrid.Canvas.Font.Style:=[fsBold];<br />
APAGrid.Canvas.TextOut(Rect.left+2,Rect.Bottom-11,'P');<br />
APAGrid.Canvas.Font.Style:=[];<br />
APAGrid.Canvas.Brush.Color:=APA[ACol,ARow].farbe;<br />
APAGrid.Canvas.Font.Color:=clBlack;<br />
APAGrid.Canvas.Pen.Color:=clBlack;<br />
end;<br />
if (APA[ACol,ARow].flag>=2)and(APA[ACol,ARow].flag
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if (APA[ACol,ARow].linieunten=true) then begin<br />
APAGrid.Canvas.Pen.Color:=clBlack;<br />
APAGrid.Canvas.Brush.Color:=clBlack;<br />
if (ACol0) then begin<br />
if (APA[ACol-1,ARow].dickunten=true)or(APA[ACol,ARow].dicklinks=true) then<br />
APAGrid.Canvas.Rectangle(Rect.Left+2,Rect.Bottom-2,Rect.Right+2,Rect.Bottom)<br />
else<br />
APAGrid.Canvas.Rectangle(Rect.Left-2,Rect.Bottom-2,Rect.Right+2,Rect.Bottom);<br />
end else<br />
APAGrid.Canvas.Rectangle(Rect.Left-2,Rect.Bottom-2,Rect.Right+2,Rect.Bottom);<br />
end;<br />
if (APA[ACol,ARow].linierechts=true) then begin<br />
APAGrid.Canvas.Pen.Color:=clBlack;<br />
APAGrid.Canvas.Brush.Color:=clBlack;<br />
APAGrid.Canvas.Rectangle(Rect.Right-2,Rect.Top-2,Rect.Right,Rect.Bottom+2);<br />
end;<br />
if (APA[ACol,ARow].linielinks=true) then begin<br />
APAGrid.Canvas.Pen.Color:=clBlack;<br />
APAGrid.Canvas.Brush.Color:=clBlack;<br />
APAGrid.Canvas.Rectangle(Rect.Left-2,Rect.Top-2,Rect.Left+2,Rect.Bottom+2);<br />
end;<br />
if (APA[ACol,ARow].dickoben=true) then begin<br />
APAGrid.Canvas.Pen.Color:=clRed;<br />
APAGrid.Canvas.Brush.Color:=clRed;<br />
APAGrid.Canvas.Rectangle(Rect.Left-2,Rect.Top-2,Rect.Right+2,Rect.top+2);<br />
end;<br />
if (APA[ACol,ARow].dickunten=true) then begin<br />
APAGrid.Canvas.Pen.Color:=clRed;<br />
APAGrid.Canvas.Brush.Color:=clRed;<br />
APAGrid.Canvas.Rectangle(Rect.Left-2,Rect.Bottom-2,Rect.Right+2,Rect.Bottom);<br />
end;<br />
if (APA[ACol,ARow].dickrechts=true) then begin<br />
APAGrid.Canvas.Pen.Color:=clRed;<br />
APAGrid.Canvas.Brush.Color:=clRed;<br />
APAGrid.Canvas.Rectangle(Rect.Right-2,Rect.Top-2,Rect.Right,Rect.Bottom+2);<br />
end;<br />
if (APA[ACol,ARow].dicklinks=true) then begin<br />
APAGrid.Canvas.Pen.Color:=clRed;<br />
APAGrid.Canvas.Brush.Color:=clRed;<br />
APAGrid.Canvas.Rectangle(Rect.Left-2,Rect.Top-2,Rect.Left+2,Rect.Bottom+2);<br />
end;<br />
if (ACol>0)and(ARow>0) then begin<br />
if (APA[ACol-1,ARow].linieoben=true)or(APA[ACol,ARow-1].linielinks=true)<br />
or (APA[ACol,ARow].linielinks=true) then begin<br />
APAGrid.Canvas.Pen.Color:=clBlack;<br />
APAGrid.Canvas.Brush.Color:=clBlack;<br />
APAGrid.Canvas.Rectangle(Rect.Left-2,Rect.Top-2,Rect.Left+2,Rect.Top+2);<br />
end;<br />
if (APA[ACol-1,ARow].dickoben=true)or(APA[ACol,ARow-1].dicklinks=true)<br />
or (APA[ACol,ARow].dicklinks=true) then begin<br />
APAGrid.Canvas.Pen.Color:=clRed;<br />
APAGrid.Canvas.Brush.Color:=clRed;<br />
APAGrid.Canvas.Rectangle(Rect.Left-2,Rect.Top-2,Rect.Left+2,Rect.Top+2);<br />
end;<br />
end;<br />
APAGrid.Canvas.Font.Size:=8;<br />
APAGrid.Canvas.Brush.Color:=APA[ACol,ARow].farbe;<br />
APAGrid.Canvas.Font.Color:=clBlack;<br />
APAGrid.Canvas.Pen.Color:=clBlack;<br />
- 308 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if (APA[ACol,ARow].materalisieren=true) then begin;<br />
APAGrid.Canvas.Pen.Color:=clRed;<br />
APAGrid.Canvas.Brush.Color:=clRed;<br />
NewRect.Left:=Rect.Left+round((Rect.Right-Rect.Left)/6);<br />
NewRect.Right:=Rect.Right-round((Rect.Right-Rect.Left)/6);<br />
NewRect.Top:=Rect.Top+round((Rect.Bottom-Rect.Top)/6);<br />
NewRect.Bottom:=Rect.Bottom-round((Rect.Bottom-Rect.Top)/6);<br />
APAGrid.Canvas.Ellipse(NewRect);<br />
APAGrid.Canvas.Font.Size:=4;<br />
APAGrid.Canvas.Font.Color:=clWhite;<br />
APAGrid.Canvas.Brush.Color:=clBlack;<br />
if APA[ACol,ARow].matcount>9 then<br />
APAGrid.Canvas.TextOut(Rect.Right-14,Rect.bottom-<br />
15,inttostr(APA[ACol,ARow].matcount))<br />
else<br />
APAGrid.Canvas.TextOut(Rect.Right-8,Rect.bottom-<br />
15,inttostr(APA[ACol,ARow].matcount));<br />
APAGrid.Canvas.Font.Size:=8;<br />
APAGrid.Canvas.Font.Color:=clWhite;<br />
APAGrid.Canvas.Brush.Color:=clRed;<br />
end;<br />
if (APA[ACol,ARow].derivative=true) then begin;<br />
APAGrid.Canvas.Pen.Color:=clGreen;<br />
APAGrid.Canvas.Brush.Color:=clGreen;<br />
NewRect.Left:=Rect.Left+round((Rect.Right-Rect.Left)/6);<br />
NewRect.Right:=Rect.Right-round((Rect.Right-Rect.Left)/6);<br />
NewRect.Top:=Rect.Top+round((Rect.Bottom-Rect.Top)/6);<br />
NewRect.Bottom:=Rect.Bottom-round((Rect.Bottom-Rect.Top)/6);<br />
APAGrid.Canvas.Ellipse(NewRect);<br />
APAGrid.Canvas.Font.Size:=8;<br />
APAGrid.Canvas.Font.Color:=clWhite;<br />
end;<br />
if (ACol=klickspalte)and(ARow=klickzeile) then begin;<br />
APAGrid.Canvas.Pen.Color:=clBlue;<br />
APAGrid.Canvas.Brush.Color:=clBlue;<br />
NewRect.Left:=Rect.Left+round((Rect.Right-Rect.Left)/6);<br />
NewRect.Right:=Rect.Right-round((Rect.Right-Rect.Left)/6);<br />
NewRect.Top:=Rect.Top+round((Rect.Bottom-Rect.Top)/6);<br />
NewRect.Bottom:=Rect.Bottom-round((Rect.Bottom-Rect.Top)/6);<br />
APAGrid.Canvas.Ellipse(NewRect);<br />
APAGrid.Canvas.Font.Size:=8;<br />
APAGrid.Canvas.Font.Color:=clWhite;<br />
end;<br />
if (Remove_Redundancy.Checked=false)or<br />
((Remove_Redundancy.Checked=true)and(APA[ACol,ARow].farbe=clYellow)) then<br />
begin;<br />
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<br />
bez);<br />
end;<br />
end;<br />
procedure TAPA_Grid.APAGridMouseMove(Sender: TObject; Shift: TShiftState;<br />
X, Y: Integer);<br />
begin<br />
aktx:=x;akty:=y;<br />
zellespalte:=APAGrid.MouseCoord(x,y).X;<br />
zellezeile:=APAGrid.MouseCoord(x,y).y;<br />
- 309 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if ((zellespalte-1)and(zellezeile-1))<br />
then begin;<br />
if (Remove_Redundancy.Checked=false)or<br />
((Remove_Redundancy.Checked=true)and(APA[zellespalte,zellezeile].farbe=clYellow)) then<br />
begin;<br />
if APA[zellespalte,zellezeile].interessant=true then begin<br />
if (APA[zellespalte,zellezeile].gewichtlevel-1)<br />
and(APA[zellespalte,zellezeile].gewichtlevelmerke then begin<br />
APA[spalte,zeile].matcount:=APA[spalte,zeile].matcount-1;<br />
end;<br />
- 310 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
end;//spalte<br />
end;//zeile<br />
matcount:=matcount-1;<br />
materialzeichnen;<br />
APAGrid.Repaint;<br />
end;<br />
procedure TAPA_Grid.Showderivatives1Click(Sender: TObject);<br />
var spalte,zeile:longint;<br />
begin<br />
//Alle Linien löschen<br />
for spalte:= 0 to anzspalten-1 do begin<br />
for zeile:=0 to anzzeilen-1 do begin<br />
APA[spalte,zeile].linieoben:=false;<br />
APA[spalte,zeile].linieunten:=false;<br />
APA[spalte,zeile].linielinks:=false;<br />
APA[spalte,zeile].linierechts:=false;<br />
APA[spalte,zeile].derivative:=false;<br />
end; //Ende von Zeilen<br />
end; //Ende von Spalten<br />
APA[zellespalte,zellezeile].derivative:=true;<br />
markierederivative(zellespalte,zellezeile);<br />
APAGrid.Repaint;<br />
end;<br />
procedure TAPA_Grid.APAGridDblClick(Sender: TObject);<br />
begin<br />
APAGrid.Repaint;<br />
end;<br />
procedure TAPA_Grid.APAGridMouseDown(Sender: TObject; Button: TMouseButton;<br />
Shift: TShiftState; X, Y: Integer);<br />
begin<br />
zellespalte:=APAGrid.MouseCoord(x,y).X;<br />
zellezeile:=APAGrid.MouseCoord(x,y).y;<br />
{klickspalte:=APAGrid.MouseCoord(x,y).X;<br />
klickzeile:=APAGrid.MouseCoord(x,y).y;}<br />
end;<br />
procedure TAPA_Grid.Button_to_Input_ScreenClick(Sender: TObject);<br />
begin<br />
gotoInput:=true;<br />
gotoSelection:=false;<br />
APA_Grid.Close;<br />
end;<br />
procedure TAPA_Grid.Button_to_Selection_ScreenClick(Sender: TObject);<br />
begin<br />
gotoInput:=false;<br />
gotoSelection:=true;<br />
APA_Grid.Close;<br />
end;<br />
procedure TAPA_Grid.Button_to_Main_MenuClick(Sender: TObject);<br />
begin<br />
Close;<br />
end;<br />
procedure TAPA_Grid.Remove_RedundancyClick(Sender: TObject);<br />
begin<br />
Removeredundancy1.Checked:=Remove_Redundancy.Checked;<br />
Apagrid.Repaint;<br />
end;<br />
procedure TAPA_Grid.ShowRedundancyfreecube1Click(Sender: TObject);<br />
- 311 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
var spalte,zeile:longint;<br />
begin<br />
klickspalte:=zellespalte;klickzeile:=zellezeile;<br />
spalte:=zellespalte;zeile:=zellezeile;<br />
while (APA[klickspalte,klickzeile].kurzbez=APA[spalte,zeile].kurzbez)<br />
and(APA[klickspalte,klickzeile].farbeclYellow) do begin<br />
klickzeile:=klickzeile-1;if klickzeile
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
matcount:=0;<br />
end;<br />
procedure TAPA_Grid.ListBox1DblClick(Sender: TObject);<br />
begin<br />
Panel3.Width:=1;<br />
end;<br />
procedure TAPA_Grid.FormShow(Sender: TObject);<br />
begin<br />
if generiereapaneu=true then begin<br />
APAGrid.Visible:=false;<br />
APAGrid.Enabled:=false;<br />
{Spalten berechnen}<br />
calculatecolumnscount;<br />
{Anz der Zielen berechnen}<br />
calculaterowcount;<br />
APAGrid.ColCount:=anzspalten;<br />
APAGrid.RowCount:=anzzeilen;<br />
{APA generieren}<br />
generate;<br />
APAGrid.Visible:=true;<br />
APAGrid.Enabled:=true;<br />
generiereapaneu:=false;<br />
Showdeterministicsolution2.Visible:=true;<br />
Removedeterministicsolution2.Visible:=false;<br />
end;<br />
end;<br />
function TAPA_Grid.getbuild(vonspalte,vonzeile,zuspalte,zuzeile:longint):Extended;<br />
begin<br />
with APA_Application do begin<br />
if (vonspaltezuspalte)or(vonzeilezuzeile) then begin<br />
if findkosten(vonspalte,vonzeile,zuspalte,zuzeile) then begin<br />
Result:=vKosten.Build;<br />
end//End of findkey<br />
else begin;<br />
if (vonspaltezuspalte)or(vonzeilezuzeile) then begin;<br />
APA_Show_Process.ausgabe('Da fehlen Kosten!!<br />
'+inttostr(vonspalte)+':'+inttostr(vonzeile)+'/'+inttostr(zuspalte)+':'+inttostr(z<br />
uzeile));//Später entfernen<br />
break:=true;<br />
end;<br />
Result:=0;<br />
end;<br />
end else Result:=0;<br />
end;//End of APA_Application}<br />
end;<br />
function TAPA_Grid.getquery(vonspalte,vonzeile,zuspalte,zuzeile:longint):Extended;<br />
begin<br />
with APA_Application do begin<br />
if (vonspaltezuspalte)or(vonzeilezuzeile) then begin<br />
if findkosten(vonspalte,vonzeile,zuspalte,zuzeile) then begin<br />
Result:=vKosten.Query;<br />
end//End of findkey<br />
else begin;<br />
if (vonspaltezuspalte)or(vonzeilezuzeile) then begin;<br />
- 313 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
APA_Show_Process.ausgabe('Da fehlen QueryKosten!!<br />
'+inttostr(vonspalte)+':'+inttostr(vonzeile)+'/'+inttostr(zuspalte)+':'+inttostr(z<br />
uzeile));//Später entfernen<br />
break:=true;end;<br />
Result:=0;<br />
end;<br />
end else Result:=0;<br />
end;//End of APA_Application<br />
end;<br />
function TAPA_Grid.auffuellen(st:string; anzahl:longint):string;<br />
begin<br />
while (length(st)
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
end;<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
end else //BFT<br />
begin;<br />
//Berechne die Tupels welche abgefragt werden<br />
anztupels:=0;<br />
for counter:=0 to anzd-1 do begin;<br />
anztupels:=anztupels+countdaten[counter,0];<br />
end;<br />
Result:=anztupels;<br />
end;<br />
end;<br />
function TAPA_Grid.deltaBftW(aktspalte,aktzeile:longint;Query:boolean):Extended;<br />
var anztupels,storetupels:Extended; //Zähler<br />
var SummeBerechnungendeltaBFTW:Extended;<br />
begin;<br />
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<br />
//Berechne die Kosten für das Erzeugen des Würfels aus dem BFT table<br />
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<br />
anztupels:=gettupel(-1,-1);<br />
storetupels:=gettupel(aktspalte,aktzeile);<br />
try<br />
if Query= true then begin<br />
SummeBerechnungendeltaBFTW:=<br />
(<br />
(<br />
(<br />
((strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(anztupels+(2*storetupels))))<br />
)<br />
/<br />
strtofloat(APA_Parameter.APA_Thomas_timemax.text)<br />
)+<br />
(<br />
(storetupels*<br />
log2(storetupels)*strtofloat(APA_Parameter.APA_Thomas_timecpu.Text))<br />
/<br />
strtofloat(APA_Parameter.APA_Thomas_timemax.text)<br />
)<br />
)<br />
* (APA_Parameter.APA_Thomas_Importance.Position/100);<br />
end else begin<br />
SummeBerechnungendeltaBFTW:=<br />
(<br />
((<br />
((strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(anztupels+(2*storetupels))))<br />
+<br />
(strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*storetupels)<br />
)<br />
/<br />
strtofloat(APA_Parameter.APA_Thomas_timemax.text)<br />
)+<br />
(<br />
(storetupels*<br />
log2(storetupels)*strtofloat(APA_Parameter.APA_Thomas_timecpu.Text))<br />
/<br />
strtofloat(APA_Parameter.APA_Thomas_timemax.text)<br />
- 315 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
)<br />
)<br />
* (APA_Parameter.APA_Thomas_Importance.Position/100);<br />
SummeBerechnungendeltaBFTW:=SummeBerechnungendeltaBFTW<br />
+<br />
((<br />
(strtofloat(APA_Parameter.APA_Thomas_timestore.text)*storetupels)<br />
/<br />
strtofloat(APA_Parameter.APA_Thomas_spacemax.text)<br />
)<br />
* (1-(APA_Parameter.APA_Thomas_Importance.Position/100))<br />
);<br />
end;<br />
except<br />
showmessage('Error in Parameters');<br />
SummeBerechnungendeltaBFTW:=0;<br />
end;<br />
Result:=SummeBerechnungendeltaBFTW;<br />
end;<br />
function<br />
TAPA_Grid.deltaVW(spalte,zeile,aktspalte,aktzeile:longint;query:boolean):Extended;<br />
var anztupels, storetupels:Extended; //Zähler<br />
var SummeBerechnungendeltaVW:Extended;<br />
begin;<br />
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<br />
//Berechne die Kosten für das Berechnen des Würfels aus dem BFT table<br />
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<br />
SummeBerechnungendeltaVW:=0;<br />
if (spalteaktspalte)or(zeileaktzeile) then begin<br />
if spalte-1 then begin<br />
anztupels:=gettupel(spalte,zeile);<br />
storetupels:=gettupel(aktspalte,aktzeile);<br />
try<br />
if Query=true then begin<br />
//ABfrage<br />
SummeBerechnungendeltaVW:=<br />
(<br />
((<br />
((strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(anztupels+(2*storetupels))))<br />
)<br />
/<br />
strtofloat(APA_Parameter.APA_Thomas_timemax.text)<br />
)+<br />
(<br />
(storetupels*<br />
log2(storetupels)*strtofloat(APA_Parameter.APA_Thomas_timecpu.Text))<br />
/<br />
strtofloat(APA_Parameter.APA_Thomas_timemax.text)<br />
)<br />
)<br />
* (APA_Parameter.APA_Thomas_Importance.Position/100);<br />
end else begin<br />
//Materialisieren<br />
SummeBerechnungendeltaVW:=<br />
(<br />
((<br />
((strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(anztupels+(2*storetupels))))<br />
+<br />
(strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*storetupels)<br />
- 316 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
)<br />
/<br />
strtofloat(APA_Parameter.APA_Thomas_timemax.text)<br />
)+<br />
(<br />
(storetupels*<br />
log2(storetupels)*strtofloat(APA_Parameter.APA_Thomas_timecpu.Text))<br />
/<br />
strtofloat(APA_Parameter.APA_Thomas_timemax.text)<br />
)<br />
)<br />
* (APA_Parameter.APA_Thomas_Importance.Position/100);<br />
SummeBerechnungendeltaVW:=SummeBerechnungendeltaVW<br />
+<br />
((<br />
(strtofloat(APA_Parameter.APA_Thomas_timestore.text)*storetupels)<br />
/<br />
strtofloat(APA_Parameter.APA_Thomas_spacemax.text)<br />
)<br />
* (1-(APA_Parameter.APA_Thomas_Importance.Position/100))<br />
);<br />
end;<br />
except<br />
showmessage('Error in Parameters');<br />
SummeBerechnungendeltaVW:=0;<br />
end;<br />
end //spalte -1<br />
else begin<br />
SummeBerechnungendeltaVW:=deltaBftW(aktspalte,aktzeile,Query);<br />
end;<br />
end;<br />
Result:=SummeBerechnungendeltaVW;<br />
end;<br />
function<br />
TAPA_Grid.GetMinDerivatOfSpalte(aktspalte,aktzeile:longint;Query:boolean):longint;<br />
var counter:longint;<br />
New:string;<br />
derivat:longint;<br />
mincost:Extended;<br />
aus:boolean;<br />
begin<br />
try<br />
derivat:=0;mincost:=0; aus:=false;<br />
counter:=0;<br />
repeat;<br />
if counter
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if (mincost=0)or<br />
(getbuild(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),aktspalte,aktzeile)
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
except<br />
Result:=0;<br />
end;<br />
end;<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if Query=false then begin<br />
if (mincost=0)or<br />
(getbuild(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),aktspalte,aktzeile)
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
spaceortime_limit_reached:=false;<br />
//Bestimmen des ersten Cube Anfang<br />
//********************************<br />
//Schleife für alle Würfel, welche noch nicht ausgewählt wurden//<br />
for zeile:=0 to anzzeilen-1 do begin;<br />
for spalte:=0 to anzspalten-1 do begin;<br />
//zeile und spalte symbolisieren einen Würfel<br />
// v welcher zugestetz werden könnte<br />
BerechneE:=0;<br />
if (APA[spalte,zeile].farbe=clYellow) then<br />
begin; //Wenn redundanzfrei dann beginne//<br />
Listbox1.Items.Add('');listbox1.Items.Add('++++++++++++++++Kontrolliere<br />
Zelle '+inttostr(spalte)+':'+inttostr(zeile));<br />
//Setzte den Wert für E(m) auf 0<br />
for aktzeile:=0 to anzzeilen-1 do begin<br />
for aktspalte:=0 to anzspalten-1 do begin<br />
//aktzeile und aktspalte symbolisieren den würfel w<br />
//Feststellen ob der Würfel redundanzfrei und ausgewählt ist//<br />
if<br />
(APA[aktspalte,aktzeile].farbe=clYellow)and(APA[aktspalte,aktzeile].gewicht0)<br />
then begin<br />
//if //aktuelle Würfel ist ein Derivat von aktellem v<br />
if<br />
(isderivat(spalte,zeile,aktspalte,aktzeile)=true)and(APA[aktspalte,aktzeile].inter<br />
essant=true) then begin<br />
listbox1.Items.Add('Schau mir das an: ist Derivat und nicht<br />
0 '+inttostr(aktspalte)+':'+inttostr(aktzeile));<br />
//Berechne Summe aller Delta w<br />
if Userandomcosts1.Checked=false then begin<br />
BerechneE:=BerechneE+<br />
((deltaBftW(aktspalte,aktzeile,false)deltaVW(spalte,zeile,aktspalte,aktzeile,false))*(APA[aktspalte,aktzeile].gewicht))<br />
;<br />
listbox1.Items.Add('Berechne'+floattostr(deltaBftW(aktspalte,aktzeile,false))+'-'<br />
+floattostr(deltaVW(spalte,zeile,aktspalte,aktzeile,false))+'*'+floattostr((APA[ak<br />
tspalte,aktzeile].gewicht)));<br />
end else begin<br />
BerechneE:=BerechneE+<br />
((getbuild(-1,-1,aktspalte,aktzeile)getbuild(spalte,zeile,aktspalte,aktzeile))*(APA[aktspalte,aktzeile].gewicht));<br />
listbox1.Items.Add('Berechne'+floattostr(getbuild(-1,-<br />
1,aktspalte,aktzeile))+'-'<br />
+floattostr(getbuild(spalte,zeile,aktspalte,aktzeile))+'*'+floattostr((APA[aktspal<br />
te,aktzeile].gewicht)));<br />
end;<br />
end; //Wenn Derivat<br />
end; //Wenn Würfel ist redundanzfrei<br />
end;{Ende von aktspalte}<br />
end;{Ende von aktzeile}<br />
if Userandomcosts1.Checked=false then begin<br />
listbox1.Items.add('Gesamtwert für BerechneE :'+floattostr(BerechneE));<br />
APA[spalte,zeile].value:=(BerechneE-deltaBftW(spalte,zeile,false));<br />
listbox1.Items.Add('Wert eintragen für Zelle<br />
'+inttostr(spalte)+':'+inttostr(zeile)+': Wert:<br />
'+floattostr(APA[spalte,zeile].value)+' Gewicht:<br />
'+floattostr((APA[spalte,zeile].gewicht)));<br />
- 320 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if APA[spalte,zeile].gewicht0 then<br />
listbox1.Items.add('=================================================');<br />
end else begin<br />
listbox1.Items.add('Gesamtwert für BerechneE :'+floattostr(BerechneE));<br />
APA[spalte,zeile].value:=(BerechneE-getbuild(-1,-1,spalte,zeile));<br />
listbox1.Items.Add('Wert eintragen für Zelle<br />
'+inttostr(spalte)+':'+inttostr(zeile)+': Wert:<br />
'+floattostr(APA[spalte,zeile].value)+' Gewicht:<br />
'+floattostr((APA[spalte,zeile].gewicht)));<br />
if APA[spalte,zeile].gewicht0 then<br />
listbox1.Items.add('=================================================');<br />
end;<br />
end{von Redundanzfrei}<br />
else APA[spalte,zeile].value:=0;<br />
end;{For Schleife spalte}<br />
end;{For Schleife zeilen}<br />
//Materialisiere als ersten Würfel jenen mit dem besten Value<br />
//Finde den höchsten Wert<br />
merkvalue:=APA[0,0].value;aktzeile:=0;aktspalte:=0;<br />
for zeile:=0 to anzzeilen-1 do begin;<br />
for spalte:=0 to anzspalten-1 do begin;<br />
if<br />
((APA[spalte,zeile].value>merkvalue)or((merkvalue=0)and(Minusnehmen1.Checked=true)<br />
))<br />
and (APA[spalte,zeile].value0) then begin<br />
merkvalue:=APA[spalte,zeile].value;//Wert merken<br />
aktspalte:=spalte;aktzeile:=zeile;//Merken der Spalte und Zeile<br />
end;<br />
end;<br />
end;<br />
if merkvalue=0 then spaceortime_limit_reached:=true;<br />
if Userandomcosts1.Checked=false then begin<br />
timemax:=timemax-(strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(gettupel(-1,-<br />
1)+(2*gettupel(aktspalte,aktzeile)))+<br />
+strtofloat(APA_Parameter.APA_Thomas_timecpu.text)*gettupel(aktspalte,aktzeile)*lo<br />
g2(gettupel(aktspalte,aktzeile))+<br />
strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*gettupel(aktspalte,aktzeile));<br />
end else begin<br />
timemax:=timemax-getbuild(-1,-1,aktspalte,aktzeile);<br />
end;<br />
spacemax:=spacemax-<br />
(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(aktspalte,aktzei<br />
le));<br />
if (spacemax
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if ProssernurersterLauf1.Checked=false then begin<br />
while (spaceortime_limit_reached=false) do begin;<br />
//Schleife für alle Würfel, welche noch nicht ausgewählt wurden//<br />
for zeile:=0 to anzzeilen-1 do begin;<br />
for spalte:=0 to anzspalten-1 do begin;<br />
//zeile und spalte symbolisieren einen Würfel<br />
// v welcher zugestetz werden könnte<br />
//Setzte den Wert für E(m) auf 0<br />
BerechneE:=0;<br />
//Alle Wuerfel Value auf 0 setzen<br />
for aktzeile:=0 to anzzeilen-1 do begin;<br />
for aktspalte:=0 to anzspalten-1 do begin;<br />
APA[aktspalte,aktzeile].value:=0;<br />
end;<br />
end;<br />
if (APA[spalte,zeile].farbe=clYellow) then<br />
begin; //Wenn redundanzfrei dann beginne//<br />
Listbox1.items.add('+++++++++++');<br />
listbox1.Items.Add('Kontrolliere zweite Schleife Zelle<br />
'+inttostr(spalte)+':'+inttostr(zeile)+': Wert:<br />
'+floattostr(APA[spalte,zeile].value)+' Gewicht:<br />
'+floattostr(APA[spalte,zeile].gewicht));<br />
//Stelle fest, ob Würfel schon zugesetzt<br />
added:=false;<br />
for counter:=0 to Memorywuerfel.Count-1 do begin<br />
New:=Memorywuerfel[counter];<br />
if<br />
(strtoint(copy(new,31,30))=zeile)and(strtoint(copy(new,1,30))=spalte) then<br />
added:=true;<br />
end;<br />
++++');<br />
if added=true then listbox1.items.add('++++ Würfel schon zugesetzt<br />
if added=false then begin;<br />
//Würfel ist noch nicht in der Menge der bereits ausgewählten Würfel//<br />
isderivatof:=false;<br />
for counter:=0 to Memorywuerfel.Count-1 do begin<br />
New:=Memorywuerfel[counter];<br />
if<br />
isderivat(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),spalte,zeile) then<br />
begin;<br />
isderivatof:=true;<br />
Listbox1.Items.Add(copy(new,1,30)+':'+copy(new,31,30)+' kann erzeugen<br />
'+inttostr(spalte)+':'+inttostr(zeile))<br />
end;<br />
end;<br />
if isderivatof=false then begin<br />
//ist kein Derivat Begin ++++++++++++++++++++++++<br />
//wird also aus dem BFT berechnet<br />
//Berechne alle Zellen ein<br />
for aktzeile:=0 to anzzeilen-1 do begin<br />
for aktspalte:=0 to anzspalten-1 do begin<br />
//aktzeile und aktspalte symbolisieren den würfel w<br />
//Feststellen ob der Würfel redundanzfrei ist//<br />
if<br />
(APA[aktspalte,aktzeile].farbe=clYellow)and(APA[aktspalte,aktzeile].gewicht0)<br />
then begin<br />
//if //aktuelle Würfel ist ein Derivat von aktellem v<br />
- 322 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if isderivat(spalte,zeile,aktspalte,aktzeile)=true then<br />
begin<br />
listbox1.Items.add('Kontrolliere Würfel<br />
'+inttostr(aktspalte)+'.'+inttostr(aktzeile));<br />
//Wenn u aus einem bereits materialisierten Würfel<br />
abgebildet werden kann<br />
isderivatof:=false;<br />
for counter:=0 to Memorywuerfel.Count-1 do begin<br />
New:=Memorywuerfel[counter];<br />
if<br />
isderivat(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),spalte,zeile) then<br />
begin;<br />
Listbox1.Items.Add(copy(new,1,30)+':'+copy(new,31,30)+' ist auch ein derivat von<br />
'+inttostr(spalte)+':'+inttostr(zeile));<br />
isderivatof:=true;<br />
end;<br />
end;<br />
if isderivatof=false then begin;<br />
if Userandomcosts1.Checked=false then begin<br />
BerechneE:=BerechneE+((deltaBftW(aktspalte,aktzeile,false)-<br />
deltaVW(spalte,zeile,aktspalte,aktzeile,false))*(APA[aktspalte,aktzeile].gewicht))<br />
;<br />
listbox1.Items.Add('Berechne'+floattostr(deltaBftW(aktspalte,aktzeile,false))+'-'<br />
+floattostr(deltaVW(spalte,zeile,aktspalte,aktzeile,false))+'*'+floattostr((APA[ak<br />
tspalte,aktzeile].gewicht)));<br />
1,aktspalte,aktzeile)-<br />
end//von Userkostenrandom<br />
else<br />
begin<br />
BerechneE:=BerechneE+((getbuild(-1,-<br />
getbuild(spalte,zeile,aktspalte,aktzeile))*(APA[aktspalte,aktzeile].gewicht));<br />
listbox1.Items.Add('Berechne'+floattostr(getbuild(-<br />
1,-1,aktspalte,aktzeile))+'-'<br />
+floattostr(getbuild(spalte,zeile,aktspalte,aktzeile))+'*'+floattostr((APA[aktspal<br />
te,aktzeile].gewicht)));<br />
end;<br />
end else<br />
begin<br />
if Userandomcosts1.Checked=false then begin<br />
BerechneE:=BerechneE+<br />
max(0,((deltaVW(GetMinDerivatOfSpalte(aktspalte,aktzeile,false),<br />
GetMinDerivatOfZeile(aktspalte,aktzeile,false),aktspalte,aktzeile,false)-<br />
deltaVW(spalte,zeile,aktspalte,aktzeile,false))*(APA[aktspalte,aktzeile].gewicht))<br />
);<br />
listbox1.Items.Add('Berechne'+floattostr(deltaVW(GetMinDerivatOfSpalte(aktspalte,a<br />
ktzeile,false),<br />
GetMinDerivatOfZeile(aktspalte,aktzeile,false),aktspalte,aktzeile,false))+'-'<br />
+floattostr(deltaVW(spalte,zeile,aktspalte,aktzeile,false))+'*'+floattostr((APA[ak<br />
tspalte,aktzeile].gewicht)));<br />
end//von Userkosten<br />
else<br />
begin<br />
BerechneE:=BerechneE+<br />
- 323 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
max(0,((getbuild(GetMinDerivatOfSpalte(aktspalte,aktzeile,false),<br />
GetMinDerivatOfZeile(aktspalte,aktzeile,false),aktspalte,aktzeile)-<br />
getbuild(spalte,zeile,aktspalte,aktzeile))*(APA[aktspalte,aktzeile].gewicht)));<br />
listbox1.Items.Add('Berechne'+floattostr(getbuild(GetMinDerivatOfSpalte(aktspalte,<br />
aktzeile,false),<br />
GetMinDerivatOfZeile(aktspalte,aktzeile,false),aktspalte,aktzeile))+'-'<br />
+floattostr(getbuild(spalte,zeile,aktspalte,aktzeile))+'*'+floattostr((APA[aktspal<br />
te,aktzeile].gewicht)));<br />
end;<br />
end;<br />
end; //Wenn Derivat<br />
end; //Wenn Würfel ist redundanzfrei<br />
end;//Ende von aktspalte<br />
end;//Ende von aktzeile<br />
if Userandomcosts1.Checked=false then begin<br />
APA[spalte,zeile].value:=BerechneE-deltaBftW(spalte,zeile,false);<br />
listbox1.Items.add('BerechneE für<br />
'+inttostr(spalte)+':'+inttostr(Zeile)+' ist '+floattostr(BerechneEdeltaBftW(spalte,zeile,false)));<br />
end//von Userkosten<br />
else begin<br />
APA[spalte,zeile].value:=BerechneE-getbuild(-1,-1,spalte,zeile);<br />
listbox1.Items.add('BerechneE für<br />
'+inttostr(spalte)+':'+inttostr(Zeile)+' ist '+floattostr(BerechneE-getbuild(-1,-<br />
1,spalte,zeile)));<br />
end;<br />
end//von ist kein Derivat ++++++++++++++++++++++<br />
else begin//von ist ein Derivat ++++++++++++++++++++++++<br />
listbox1.Items.Add('is a derivat Cell<br />
'+inttostr(spalte)+':'+inttostr(zeile));<br />
for aktzeile:=0 to anzzeilen-1 do begin<br />
for aktspalte:=0 to anzspalten-1 do begin<br />
//aktzeile und aktspalte symbolisieren den würfel w<br />
//Feststellen ob der Würfel redundanzfrei ist//<br />
if (APA[aktspalte,aktzeile].farbe=clYellow)<br />
and(APA[aktspalte,aktzeile].gewicht0) then begin<br />
begin<br />
//if //aktuelle Würfel ist ein Derivat von aktellem v<br />
if isderivat(spalte,zeile,aktspalte,aktzeile)=true then<br />
if Userandomcosts1.Checked=false then begin<br />
BerechneE:=BerechneE+<br />
max(0,((deltaVW(GetMinDerivatOfSpalte(aktspalte,aktzeile,false),<br />
GetMinDerivatOfZeile(aktspalte,aktzeile,false),aktspalte,aktzeile,false)-<br />
deltaVW(spalte,zeile,aktspalte,aktzeile,false))*(APA[aktspalte,aktzeile].gewicht))<br />
);<br />
listbox1.items.add('Min Parent is<br />
'+inttostr(GetMinDerivatOfSpalte(aktspalte,aktzeile,false))+':'+<br />
inttostr(GetMinDerivatOfZeile(aktspalte,aktzeile,false)));<br />
listbox1.Items.Add('Berechne 0 oder<br />
'+floattostr(deltaVW(GetMinDerivatOfSpalte(aktspalte,aktzeile,false),<br />
GetMinDerivatOfZeile(aktspalte,aktzeile,false),aktspalte,aktzeile,false))+'-'<br />
- 324 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
+floattostr(deltaVW(spalte,zeile,aktspalte,aktzeile,false))+'*'+floattostr((APA[ak<br />
tspalte,aktzeile].gewicht)));<br />
end//of Userkosten<br />
else begin<br />
BerechneE:=BerechneE+<br />
max(0,((getbuild(GetMinDerivatOfSpalte(aktspalte,aktzeile,false),<br />
GetMinDerivatOfZeile(aktspalte,aktzeile,false),aktspalte,aktzeile)-<br />
getbuild(spalte,zeile,aktspalte,aktzeile))*(APA[aktspalte,aktzeile].gewicht)));<br />
listbox1.items.add('Min Parent is<br />
'+inttostr(GetMinDerivatOfSpalte(aktspalte,aktzeile,false))+':'+<br />
inttostr(GetMinDerivatOfZeile(aktspalte,aktzeile,false)));<br />
listbox1.Items.Add('Berechne 0 oder<br />
'+floattostr(getbuild(GetMinDerivatOfSpalte(aktspalte,aktzeile,false),<br />
GetMinDerivatOfZeile(aktspalte,aktzeile,false),aktspalte,aktzeile))+'-'<br />
+floattostr(getbuild(spalte,zeile,aktspalte,aktzeile))+'*'+floattostr((APA[aktspal<br />
te,aktzeile].gewicht)));<br />
end;<br />
end; //Wenn Derivat<br />
end; //Wenn Würfel ist redundanzfrei<br />
end;//Ende von aktspalte<br />
end;//Ende von aktzeile<br />
if Userandomcosts1.Checked=false then begin<br />
APA[spalte,zeile].value:=BerechneE-<br />
deltaVW(GetMinDerivatOfSpalte(spalte,zeile,false),GetMinDerivatOfZeile(spalte,zeil<br />
e,false),spalte,zeile,false);<br />
listbox1.Items.add('BerechneE für<br />
'+inttostr(spalte)+':'+inttostr(Zeile)+' ist<br />
'+floattostr(APA[spalte,zeile].value));<br />
end//Userkosten<br />
else begin<br />
APA[spalte,zeile].value:=BerechneE-<br />
getbuild(GetMinDerivatOfSpalte(spalte,zeile,false),GetMinDerivatOfZeile(spalte,zei<br />
le,false),spalte,zeile);<br />
listbox1.Items.add('BerechneE für<br />
'+inttostr(spalte)+':'+inttostr(Zeile)+' ist<br />
'+floattostr(APA[spalte,zeile].value));<br />
end;<br />
end;//von ist ein Derivat ++++++++++++++++++++++++++++<br />
end; //Würfel ist noch nicht in der Liste ENDE<br />
end;//von Redundanzfrei<br />
end;//For Schleife spalte<br />
end;//For Schleife zeilen<br />
//Materialisiere als nächsten Würfel jenen mit dem besten Value<br />
//Finde den höchsten Wert<br />
merkvalue:=0;aktzeile:=0;aktspalte:=0;isderivatof:=false;<br />
for zeile:=0 to anzzeilen-1 do begin;<br />
for spalte:=0 to anzspalten-1 do begin;<br />
if<br />
((APA[spalte,zeile].value>merkvalue)or((merkvalue=0)and(Minusnehmen1.Checked=true)<br />
))<br />
and (APA[spalte,zeile].value0) then begin<br />
merkvalue:=APA[spalte,zeile].value;//Wert merken<br />
- 325 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
aktspalte:=spalte;aktzeile:=zeile;//Merken der Spalte und Zeile<br />
//Festellen, ob aus dem BFT materialisiert wird oder aus einem bereits<br />
//materialisierten Würfel<br />
for counter:=0 to Memorywuerfel.Count-1 do begin<br />
New:=Memorywuerfel[counter];<br />
if<br />
isderivat(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),spalte,zeile) then<br />
begin;<br />
isderivatof:=true;<br />
end;<br />
end;<br />
end;<br />
end;<br />
end;<br />
if merkvalue=0 then begin;<br />
spaceortime_limit_reached:=true; //Wenn kein Würfel einen Wert hat beenden<br />
showmessage('Alle Würfel 0');<br />
end<br />
else<br />
begin;<br />
if isderivatof=false then begin<br />
//Wird aus dem BFT erzeugt<br />
if Userandomcosts1.Checked=false then begin<br />
timemax:=timemax-<br />
(strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(gettupel(-1,-<br />
1)+(2*gettupel(aktspalte,aktzeile)))+<br />
+strtofloat(APA_Parameter.APA_Thomas_timecpu.text)*gettupel(aktspalte,aktzeile)*lo<br />
g2(gettupel(aktspalte,aktzeile))+<br />
strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*gettupel(aktspalte,aktzeile));<br />
end else begin<br />
timemax:=timemax-getbuild(-1,-1,aktspalte,aktzeile);<br />
end;<br />
spacemax:=spacemax-<br />
(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(aktspalte,aktzei<br />
le));<br />
end else begin<br />
//Wird aus bereits materialisiertem Würfel erzeugt<br />
if Userandomcosts1.Checked=false then begin<br />
timemax:=timemax-(strtofloat(APA_Parameter.APA_Thomas_timeio.text)*<br />
(gettupel(GetMinDerivatOfSpalte(aktspalte,aktzeile,false),GetMinDerivatOfZeile(akt<br />
spalte,aktzeile,false))+(2*gettupel(aktspalte,aktzeile)))+<br />
+strtofloat(APA_Parameter.APA_Thomas_timecpu.text)*gettupel(aktspalte,aktzeile)*lo<br />
g2(gettupel(aktspalte,aktzeile))+<br />
strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*gettupel(aktspalte,aktzeile));<br />
end else begin<br />
timemax:=timemaxgetbuild(GetMinDerivatOfSpalte(aktspalte,aktzeile,false),GetMinDerivatOfZeile(akts<br />
palte,aktzeile,false),<br />
aktspalte,aktzeile);<br />
end;<br />
spacemax:=spacemax-<br />
(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(aktspalte,aktzei<br />
le));<br />
end;<br />
end;<br />
- 326 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if timemax
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
var merksecondcosts:Extended;<br />
begin<br />
Button_remove_materialized_cubes.Click;<br />
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');<br />
{$i-}<br />
reset(fKosten);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('cost database error ');exit;end;<br />
try<br />
APA_Grid.Enabled:=false;<br />
if (APA_Options.APA_ShowScreenheuristic.Checked) then begin<br />
APA_Show_Process.Show;<br />
APA_Show_Process.APA_Protocoll.Clear;<br />
end;<br />
listbox1.Items.Clear;<br />
{*********************************************************}<br />
{1. Vorbereitungen für die Iteration}<br />
{*********************************************************}<br />
APA_Show_Process.ausgabe('Start Thomas Achs heuristic ...');<br />
{1.a Erzeuge die Liste der materialisierungswürdigen Würfel}<br />
PossibleCubes:=TStringList.Create();<br />
SecondCubes:=TStringList.Create();<br />
MerkMatCubes:=TList.Create();<br />
MerkMatCubesfertig:=TList.Create();<br />
MatCubes:=TStringList.Create();<br />
SecondMatCubes:=TStringList.Create();<br />
try<br />
APA_Show_Process.ausgabe('Search for required cubes...');<br />
counter:=0;<br />
for aktzeile:=0 to anzzeilen-1 do begin<br />
for aktspalte:=0 to anzspalten-1 do begin<br />
if (APA[aktspalte,aktzeile].interessant=true)and<br />
(APA[aktspalte,aktzeile].farbe=clYellow) then begin//Auswählen des Würfels<br />
listbox1.Items.Add('Required Cube:<br />
'+auffuellen(inttostr(aktspalte),10)+auffuellen(inttostr(aktzeile),10));<br />
PossibleCubes.Add(auffuellen(inttostr(aktspalte),10)+auffuellen(inttostr(aktzeile)<br />
,10));<br />
counter:=counter+1;<br />
end;//of Auswählen des Würfels<br />
end;//of aktspalte<br />
end;//of aktzeile<br />
APA_Show_Process.ausgabe(' Found '+inttostr(counter)+' required Cubes');<br />
{1.b Setze Derivate zu}<br />
if tomohnederivate1.Checked=false then begin<br />
APA_Show_Process.ausgabe('Search for parent cubes or required cubes...');<br />
counter:=0;<br />
for aktzeile:=0 to anzzeilen-1 do begin<br />
for aktspalte:=0 to anzspalten-1 do begin<br />
if<br />
(APA[aktspalte,aktzeile].farbe=clYellow)and(APA[aktspalte,aktzeile].interessant=fa<br />
lse) then begin<br />
count_of_derivates:=0;<br />
for derivspalte:=0 to anzspalten-1 do begin;<br />
for derivzeile:=0 to anzzeilen-1 do begin;<br />
if (APA[derivspalte,derivzeile].interessant=true)and<br />
(APA[derivspalte,derivzeile].farbe=clYellow) then begin<br />
if isderivat(aktspalte,aktzeile,derivspalte,derivzeile) then begin<br />
//Jetzt kontrollieren wir, ob dieser Würfel auch noch ein Derivat eines<br />
anderen Würfels<br />
count_of_derivates:=count_of_derivates+1;<br />
end;//Ende von derivat<br />
end;//Ende von interessant<br />
- 328 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
end;//of derivzeile<br />
end;//of derivsspalte<br />
if count_of_derivates>=1 then begin<br />
listbox1.Items.Add('Derivat Cube:<br />
'+auffuellen(inttostr(aktspalte),10)+auffuellen(inttostr(aktzeile),10));<br />
PossibleCubes.Add(auffuellen(inttostr(aktspalte),10)+auffuellen(inttostr(aktzeile)<br />
,10));<br />
counter:=counter+1;<br />
end;<br />
end;//von Yellow<br />
end;//aktspalte<br />
end;//aktzeile<br />
APA_Show_Process.ausgabe('Found '+inttostr(counter)+' parent cubes of required<br />
cubes...');<br />
end;//of tomohnederivate1<br />
Setcount:=1;<br />
NewSetsforEachIteration:=strtoint(trim(APA_Parameter.APA_Thomas_newsetsoneachiteration.t<br />
ext));<br />
maxSets:=strtoint(trim(APA_Parameter.APA_Thomas_countofsets.text));<br />
setlength(Sets,MaxSets);<br />
APA_Show_Process.ausgabe('Set of possible cubes of '+inttostr(counter)+' cubes is parent<br />
cubes union required cubes');<br />
{1.c. Setze limits}<br />
spaceortimelimitreached:=false;<br />
timemax:=strtofloat(APA_Parameter.APA_Thomas_timemax.Text);<br />
spacemax:=strtofloat(APA_Parameter.APA_Thomas_spacemax.Text);<br />
{*********************************************************}<br />
{Ende 1. Vorbereitungen für die Iteration}<br />
{*********************************************************}<br />
{*********************************************************}<br />
{2. Iterationen der Sets}<br />
{*********************************************************}<br />
Setcounter:=-1;<br />
repeat;<br />
{*********************************************************}<br />
{2.1 Vorbereiten des Startsets für die Iteration}<br />
{*********************************************************}<br />
APA_Show_Process.ausgabe('Generate '+inttostr(Setcounter+2)+' Set');<br />
APA_Show_Process.ausgabe('Add the best cube to the set as long as no limit reached ');<br />
if (Setcounter
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
end;<br />
end;<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
for zahler2:=0 to zahler do begin<br />
if<br />
(isderivat(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],<br />
11,10)),<br />
aktspalte,aktzeile)=true)and(zahlerzahler2) then<br />
begin;<br />
if (Userandomcosts1.Checked=false) then begin<br />
if (MinMatCosts><br />
deltaVW(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],11,<br />
10)),<br />
aktspalte,aktzeile,false))<br />
then<br />
begin;<br />
parentzeile:=strtoint(copy(MatCubes[zahler2],11,10));<br />
parentspalte:=strtoint(copy(MatCubes[zahler2],1,10));<br />
end;<br />
end//of keine Zufallskosten<br />
else<br />
begin//Wenn Zufallskosten<br />
if (MinMatCosts><br />
getbuild(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],11<br />
,10)),<br />
aktspalte,aktzeile))<br />
then<br />
begin;<br />
parentzeile:=strtoint(copy(MatCubes[zahler2],11,10));<br />
parentspalte:=strtoint(copy(MatCubes[zahler2],1,10));<br />
end;<br />
end;//Ende Wenn Zufallskosten<br />
end;<br />
end;<br />
//Ende Feststellen des Würfels, welcher Materialisert werden soll und woher<br />
if (Userandomcosts1.Checked=false) then begin<br />
timemax:=timemax-<br />
(strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(gettupel(-1,-<br />
1)+(2*gettupel(aktspalte,aktzeile)))+<br />
+strtofloat(APA_Parameter.APA_Thomas_timecpu.text)*gettupel(aktspalte,aktzeile)*lo<br />
g2(gettupel(aktspalte,aktzeile))+<br />
strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*gettupel(aktspalte,aktzeile));<br />
spacemax:=spacemax-<br />
(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(aktspalte,aktzei<br />
le));<br />
end else begin<br />
timemax:=timemax-getbuild(parentspalte,parentzeile,aktspalte,aktzeile);;<br />
spacemax:=spacemax-<br />
(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(aktspalte,aktzei<br />
le));<br />
end;<br />
{*********************************************************}<br />
- 330 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
{Ende 2.1 Vorbereiten des Startsets für die Iteration}<br />
{*********************************************************}<br />
{*********************************************************}<br />
{2.2. Beginn der Iteration des aktuellen Sets}<br />
{*********************************************************}<br />
spaceortimelimitreached:=false;<br />
while(spaceortimelimitreached=false)and(stop=false) do begin<br />
for zahler:=0 to PossibleCubes.Count-1 do begin<br />
aktspalte:=strtoint(copy(PossibleCubes[zahler],1,10));<br />
aktzeile:=strtoint(copy(PossibleCubes[zahler],11,10));<br />
SecondCubes.Clear;<br />
//Feststellen des Würfels, welcher Materialisert werden soll und woher<br />
bereitsmaterialisiert:=false;<br />
for zahler2:=0 to MatCubes.Count-1 do begin<br />
if PossibleCubes[zahler]=MatCubes[zahler2] then begin;<br />
bereitsmaterialisiert:=true;<br />
end;<br />
end;<br />
if bereitsmaterialisiert=false then begin<br />
//? gibt es ein x?<br />
kannabgeleitetwerden:=false;<br />
if (Userandomcosts1.Checked=false) then<br />
MinMatCosts:=deltaBftW(aktspalte,aktzeile,false) else<br />
MinMatCosts:=getbuild(-1,-1,aktspalte,aktzeile);<br />
parentzeile:=-1;parentspalte:=-1;<br />
{*********************************************************}<br />
{2.2.1. Feststellen des Cubes aus dem der Cube c (zahler) materialisiert wird:<br />
Dazu kontrolliere alle bereits materialisierten Cubes z (zahler2),<br />
ob c aus z abgeleitet werden kann}<br />
{*********************************************************}<br />
for zahler2:=0 to MatCubes.Count-1 do begin<br />
if<br />
isderivat(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],1<br />
1,10)),<br />
aktspalte,aktzeile)=true then<br />
begin;<br />
if (Userandomcosts1.Checked=false) then begin<br />
if (MinMatCosts><br />
deltaVW(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],11,<br />
10)),<br />
aktspalte,aktzeile,false))<br />
then<br />
begin;<br />
kannabgeleitetwerden:=true;<br />
parentzeile:=strtoint(copy(MatCubes[zahler2],11,10));<br />
parentspalte:=strtoint(copy(MatCubes[zahler2],1,10));<br />
MinMatCosts:=deltaVW(parentspalte,parentzeile,aktspalte,aktzeile,false);<br />
end;<br />
end//of keine Zufallskosten<br />
else<br />
begin//Wenn Zufallskosten<br />
if (MinMatCosts><br />
getbuild(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],11<br />
,10)),<br />
aktspalte,aktzeile))<br />
then<br />
begin;<br />
kannabgeleitetwerden:=true;<br />
parentzeile:=strtoint(copy(MatCubes[zahler2],11,10));<br />
- 331 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
parentspalte:=strtoint(copy(MatCubes[zahler2],1,10));<br />
MinMatCosts:=getbuild(parentspalte,parentzeile,aktspalte,aktzeile);<br />
end;<br />
end;//Ende Wenn Zufallskosten<br />
end;//isderivat<br />
end;//for zahler2<br />
//Ende Feststellen des Würfels, welcher Materialisert werden soll und woher<br />
{*********************************************************}<br />
{Ende 2.2.1. Feststellen des Cubes aus dem der Cube c (zahler) materialisiert wird:<br />
Dazu kontrolliere alle bereits materialisierten Cubes z (zahler2),<br />
ob c aus z abgeleitet werden kann}<br />
{*********************************************************}<br />
{*********************************************************}<br />
{2.2.2. Festellen der Derivate und der Abfragekosten<br />
der Summe der Derivate für den Cube c}<br />
{*********************************************************}<br />
Summederiv:=0;//Summe der Werte der Derivate<br />
for zahler3:=0 to PossibleCubes.Count-1 do begin<br />
derivspalte:=strtoint(copy(PossibleCubes[zahler3],1,10));<br />
derivzeile:=strtoint(copy(PossibleCubes[zahler3],11,10));<br />
faktor:=APA[derivspalte,derivzeile].gewicht;<br />
if APA[derivspalte,derivzeile].interessant=true then begin<br />
if isderivat(aktspalte,aktzeile,derivspalte,derivzeile)=true then<br />
//dies ist der Würfel u<br />
begin;<br />
//? kann derivat abgeleitet werden?<br />
kannderivatabgeleitetwerden:=false;<br />
if (Userandomcosts1.Checked=false) then begin<br />
if parentspalte-1 then<br />
MinQueryCosts:=deltaVW(parentspalte,parentzeile,aktspalte,aktzeile,false)<br />
else<br />
MinQueryCosts:=deltaBftW(aktspalte,aktzeile,false);<br />
end else<br />
MinQueryCosts:=getbuild(parentspalte,parentzeile,aktspalte,aktzeile);<br />
parentderivatspalte:=parentspalte;parentderivatzeile:=parentzeile;<br />
for zahler2:=0 to MatCubes.Count-1 do begin<br />
if<br />
isderivat(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],1<br />
1,10)),<br />
derivspalte,derivzeile)=true then<br />
begin;<br />
if (Userandomcosts1.Checked=false) then begin<br />
if (MinQueryCosts><br />
deltaVW(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],11,<br />
10)),<br />
derivspalte,derivzeile,true))<br />
then<br />
begin;<br />
kannderivatabgeleitetwerden:=true;<br />
parentderivatzeile:=strtoint(copy(MatCubes[zahler2],11,10));<br />
parentderivatspalte:=strtoint(copy(MatCubes[zahler2],1,10));<br />
MinQueryCosts:=deltaVW(parentderivatspalte,parentderivatzeile,derivspalte,derivzei<br />
le,true);<br />
end;<br />
end//of keine Zufallskosten<br />
else<br />
begin//Wenn Zufallskosten<br />
- 332 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if (MinQueryCosts><br />
getquery(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],11<br />
,10)),<br />
derivspalte,derivzeile))<br />
then<br />
begin;<br />
kannderivatabgeleitetwerden:=true;<br />
parentderivatzeile:=strtoint(copy(MatCubes[zahler2],11,10));<br />
parentderivatspalte:=strtoint(copy(MatCubes[zahler2],1,10));<br />
MinQueryCosts:=getquery(parentderivatspalte,parentderivatzeile,derivspalte,derivze<br />
ile);<br />
end;<br />
end;//Ende Wenn Zufallskosten<br />
end;<br />
end;<br />
{*********************************************************}<br />
{2.2.2.1. Berechnen der Verbesserung der Abfragekosten<br />
durch das Materialisieren von c}<br />
{*********************************************************}<br />
if kannabgeleitetwerden=false then begin<br />
if kannderivatabgeleitetwerden=false then begin<br />
if (Userandomcosts1.Checked=false) then begin<br />
Summederiv:=Summederiv+<br />
max(0,(deltaBFTw(derivspalte,derivzeile,true)-<br />
Deltavw(aktspalte,aktzeile,derivspalte,derivzeile,true)))<br />
*faktor;<br />
end else begin<br />
Summederiv:=Summederiv+<br />
max(0,(getquery(-1,-1,derivspalte,derivzeile)-<br />
getquery(aktspalte,aktzeile,derivspalte,derivzeile)))<br />
*faktor;<br />
end;<br />
end else begin<br />
if (Userandomcosts1.Checked=false) then begin<br />
Summederiv:=Summederiv+max(0,<br />
(deltaVW(parentderivatspalte,parentderivatzeile,derivspalte,derivzeile,true)-<br />
Deltavw(aktspalte,aktzeile,derivspalte,derivzeile,true))<br />
*faktor);<br />
end else begin<br />
Summederiv:=Summederiv+max(0,<br />
(getquery(parentderivatspalte,parentderivatzeile,derivspalte,derivzeile)-<br />
getquery(aktspalte,aktzeile,derivspalte,derivzeile))<br />
*faktor);<br />
end;<br />
end;<br />
end else begin<br />
//kannabgeleitet werden =true<br />
if (Userandomcosts1.Checked=false) then begin<br />
Summederiv:=Summederiv+max(0,<br />
(deltaVW(parentderivatspalte,parentderivatzeile,derivspalte,derivzeile,true)-<br />
Deltavw(aktspalte,aktzeile,derivspalte,derivzeile,true))<br />
*faktor);<br />
end else<br />
begin<br />
Summederiv:=Summederiv+max(0,<br />
(getquery(parentderivatspalte,parentderivatzeile,derivspalte,derivzeile)-<br />
- 333 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
end;<br />
end;<br />
getquery(aktspalte,aktzeile,derivspalte,derivzeile))<br />
*faktor);<br />
{*********************************************************}<br />
{Ende 2.2.2.1. Berechnen der Verbesserung der Abfragekosten<br />
durch das Materialisieren von c}<br />
{*********************************************************}<br />
end;//of isderivat<br />
end;//of ist interessant<br />
end;//of zahler3<br />
{*********************************************************}<br />
{Ende 2.2.2. Festellen der Derivate und der Abfragekosten<br />
der Summe der Derivate für den Cube c}<br />
{*********************************************************}<br />
{*********************************************************}<br />
{2.2.3. Berechnen der Verbesserung der<br />
Gesamtkosten durch das Materialisieren von c}<br />
{*********************************************************}<br />
if kannabgeleitetwerden=false then begin<br />
if (Userandomcosts1.Checked=false) then begin<br />
//Eintragen des Wertes<br />
APA[aktspalte,aktzeile].value:=Summederiv-<br />
DeltaBftw(aktspalte,aktzeile,false);<br />
APA[aktspalte,aktzeile].value2:=DeltaBftw(aktspalte,aktzeile,false);<br />
end else<br />
begin<br />
//Eintragen des Wertes<br />
APA[aktspalte,aktzeile].value:=Summederiv-getbuild(-1,-<br />
1,aktspalte,aktzeile);<br />
APA[aktspalte,aktzeile].value2:=getbuild(-1,-1,aktspalte,aktzeile);<br />
end;<br />
end else begin<br />
if (Userandomcosts1.Checked=false) then begin<br />
APA[aktspalte,aktzeile].value:=Summederiv-<br />
DeltaVW(parentspalte,parentzeile,aktspalte,aktzeile,false);<br />
APA[aktspalte,aktzeile].value2:=DeltaVW(parentspalte,parentzeile,aktspalte,aktzeil<br />
e,false);<br />
end else<br />
begin<br />
APA[aktspalte,aktzeile].value:=Summederivgetbuild(parentspalte,parentzeile,aktspalte,aktzeile);<br />
APA[aktspalte,aktzeile].value2:=getbuild(parentspalte,parentzeile,aktspalte,aktzei<br />
le);<br />
end;<br />
end;<br />
end;//of bereitsmateralisiert<br />
{*********************************************************}<br />
{Ende 2.2.3. Berechnen der Verbesserung der<br />
Gesamtkosten durch das Materialisieren von c}<br />
{*********************************************************}<br />
end;//of zahler<br />
{*********************************************************}<br />
{2.2.4 Gibt es einen Cube c mit Positivem dK(c) (Kostenersparnis)<br />
und innerhalb der Limits: True- dann setze den c mit Max(dK(c))<br />
dem aktuellen Set zu; False - dann schließe das Set ab}<br />
{*********************************************************}<br />
maxvalue:=0;<br />
nocubefound:=true;<br />
for zahler:=0 to PossibleCubes.Count-1 do begin<br />
listbox1.items.Add('Würfel '+PossibleCubes[zahler]);<br />
- 334 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
listbox1.items.add(floattostr(APA[strtoint(copy(PossibleCubes[zahler],1,10)),strto<br />
int(copy(PossibleCubes[zahler],11,10))].value));<br />
{if APA[strtoint(copy(PossibleCubes[zahler],1,10)),<br />
strtoint(copy(PossibleCubes[zahler],11,10))].value>maxvalue then begin}<br />
aktspalte:=strtoint(copy(PossibleCubes[zahler],1,10));<br />
aktzeile:=strtoint(copy(PossibleCubes[zahler],11,10));<br />
Application.ProcessMessages;<br />
//Feststellen, ob bereits materialisiert<br />
bereitsmaterialisiert:=false;<br />
for zahler2:=0 to MatCubes.Count-1 do begin<br />
if PossibleCubes[zahler]=MatCubes[zahler2] then begin;<br />
bereitsmaterialisiert:=true;<br />
listbox1.Items.Add('Schon materalisiert');<br />
end;<br />
end;<br />
//Feststellen, ob in Limits überschritten<br />
alttimemax:=timemax;altspacemax:=spacemax;<br />
listbox1.items.Add('Try Cube<br />
'+auffuellen(inttostr(aktspalte),10)+auffuellen(inttostr(aktzeile),10));<br />
listbox1.items.add('Value: '+floattostr(APA[aktspalte,aktzeile].value));<br />
if (Userandomcosts1.Checked=false) then begin<br />
timemax:=timemax-<br />
(strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(gettupel(-1,-<br />
1)+(2*gettupel(aktspalte,aktzeile)))+<br />
+strtofloat(APA_Parameter.APA_Thomas_timecpu.text)*gettupel(aktspalte,aktzeile)*lo<br />
g2(gettupel(aktspalte,aktzeile))+<br />
strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*gettupel(aktspalte,aktzeile));<br />
spacemax:=spacemax-<br />
(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(aktspalte,aktzei<br />
le));<br />
end else begin<br />
timemax:=timemax-APA[aktspalte,aktzeile].value2;<br />
spacemax:=spacemax-<br />
(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(aktspalte,aktzei<br />
le));<br />
end;<br />
listbox1.items.add('timemax('+floattostr(timemax)+')');<br />
listbox1.items.add('spacemax('+floattostr(spacemax)+')');<br />
if (timemaxmaxvalue)<br />
and(APA[strtoint(copy(PossibleCubes[zahler],1,10)),<br />
strtoint(copy(PossibleCubes[zahler],11,10))].value>0) then begin<br />
maxvalue:=APA[strtoint(copy(PossibleCubes[zahler],1,10)),<br />
- 335 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
strtoint(copy(PossibleCubes[zahler],11,10))].value;<br />
merkspalte:=strtoint(copy(PossibleCubes[zahler],1,10));//Merken der Spalte des<br />
neuen Cubes<br />
merkzeile:=strtoint(copy(PossibleCubes[zahler],11,10));//Merken der Zeile des<br />
neuen Cubes<br />
nocubefound:=false;<br />
listbox1.Items.Add('Maxvalue:'+floattostr(maxvalue));<br />
end;<br />
end;<br />
{end;}<br />
end;//of zahler<br />
if nocubefound=false then begin<br />
listbox1.items.Add('Materialize Cube<br />
'+auffuellen(inttostr(merkspalte),10)+auffuellen(inttostr(merkzeile),10));<br />
listbox1.items.add('Value: '+floattostr(APA[merkspalte,merkzeile].value));<br />
listbox1.items.add('================');<br />
//Materialisiere den besten Cube<br />
MatCubes.Add(auffuellen(inttostr(merkspalte),10)+auffuellen(inttostr(merkzeile),10<br />
));<br />
foundbestcube:=true;<br />
//Timemax und spacemax berechnen<br />
if (Userandomcosts1.Checked=false) then begin<br />
timemax:=timemax-<br />
(strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(gettupel(-1,-<br />
1)+(2*gettupel(merkspalte,merkzeile)))+<br />
+strtofloat(APA_Parameter.APA_Thomas_timecpu.text)*gettupel(merkspalte,merkzeile)*<br />
log2(gettupel(merkspalte,merkzeile))+<br />
strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*gettupel(merkspalte,merkzeile)<br />
);<br />
spacemax:=spacemax-<br />
(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(merkspalte,merkz<br />
eile));<br />
end else begin<br />
timemax:=timemax-APA[merkspalte,merkzeile].value2;<br />
spacemax:=spacemax-<br />
(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(merkspalte,merkz<br />
eile));<br />
end;<br />
//Entferne aktuell besten Würfel aus der Liste Secondcubes<br />
zahlersecond2:=0;<br />
repeat;<br />
if SecondCubes.count>0 then begin<br />
if<br />
(SecondCubes[zahlersecond2]=auffuellen(inttostr(merkspalte),10)+auffuellen(inttost<br />
r(merkzeile),10))<br />
then begin;<br />
SecondCubes.Delete(zahlersecond2);<br />
zahlersecond2:=SecondCubes.count;<br />
end;<br />
end;<br />
zahlersecond2:=zahlersecond2+1;<br />
until (zahlersecond2>SecondCubes.count-1);<br />
{*********************************************************}<br />
{2.2.4.1 Gibt es noch NewSetsForEachIteration Cubes,<br />
welche das Limit erfüllen dann wähle die NewSetsForEachIteration<br />
besten Cubes und eröffne neue Sets solange bis MaxSets erreicht.}<br />
{*********************************************************}<br />
//Erzeuge die neuen Wege, welche noch berechnet werden sollen<br />
- 336 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
listbox1.items.Add('Try adding '+inttostr(NewSetsforEachIteration)+' new<br />
Sets');<br />
for zahlersecond2:=1 to NewSetsforEachIteration do begin<br />
merksecondcosts:=0;<br />
merkepossecond:=-1;<br />
merkzeilesecond:=-1;merkspaltesecond:=-1;<br />
for zahlersecond1:=0 to SecondCubes.count-1 do begin;<br />
//Finde zweitbesten Cube<br />
if (merkepossecond=-<br />
1)or(merksecondcosts0) then begin<br />
//Neuen Weg erzeugen<br />
if (Setcount0) then begin<br />
SecondMatCubes[SecondMatCubes.Count-1]:=<br />
auffuellen(inttostr(merkspaltesecond),10)+auffuellen(inttostr(merkzeilesecond),10)<br />
;<br />
listbox1.items.Add('Found '+inttostr(zahlersecond2+1)+' best Cube:<br />
'+SecondMatCubes[SecondMatCubes.Count-1]);<br />
if merkepossecond-1 then SecondCubes.Delete(merkepossecond);<br />
Cube');<br />
NewStringList:=TStringList.Create;<br />
NewStringList.Clear;<br />
NewStringList.AddStrings(SecondMatCubes);<br />
MerkMatCubes.Add(NewStringList);<br />
end//Ende if (SecondMatCubes.Count>0<br />
else<br />
listbox1.items.Add('Did not found '+inttostr(zahlersecond2+2)+' best<br />
end;//Ende if (Setcount0)<br />
end;//zahlersecond2<br />
{*********************************************************}<br />
{Ende 2.2.4.1 Gibt es noch NewSetsForEachIteration Cubes,<br />
welche das Limit erfüllen dann wähle die NewSetsForEachIteration<br />
besten Cubes und eröffne neue Sets solange bis MaxSets erreicht.}<br />
{*********************************************************}<br />
end else spaceortimelimitreached:=true;<br />
{*********************************************************}<br />
{Ende 2.2.4 Gibt es einen Cube c mit Positivem dK(c) (Kostenersparnis)<br />
und innerhalb der Limits: True- dann setze den c mit Max(dK(c))<br />
dem aktuellen Set zu; False - dann schließe das Set ab}<br />
{*********************************************************}<br />
end;//of spaceortimelimitreached<br />
{*********************************************************}<br />
{Ende 2.2. Beginn der Iteration des aktuellen Sets}<br />
{*********************************************************}<br />
{Speichere die MatCubes in der Liste}<br />
if MatCubes.count>0 then begin<br />
- 337 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
NewStringLIst:=TStringList.Create;<br />
NewStringList.Clear;<br />
NewStringList.AddStrings(MatCubes);<br />
NewStringList:=getrightOrdertom(NewStringList);<br />
MerkMatCubesfertig.Add(NewStringList);<br />
APA_Show_Process.ausgabe(inttostr(Setcounter+2)+' Set found contain cubes ');<br />
for counter:=0 to MatCubes.Count-1 do begin<br />
APA_Show_Process.ausgabe('Cube No '+inttostr(counter)+'<br />
('+inttostr(strtoint(copy(MatCubes[counter],1,10)))+':'+<br />
inttostr(strtoint(copy(MatCubes[counter],11,10)))+')');<br />
end;<br />
end;<br />
end;//of MerkMatCubes<br />
Setcounter:=Setcounter+1;<br />
until (Setcounter>=maxSets-1)or(Setcounter>Setcount)or(stop=true);//of wayszahler<br />
{*********************************************************}<br />
{Ende 2. Iteration der Sets}<br />
{*********************************************************}<br />
APA_Show_Process.ausgabe(inttostr(Setcounter+1)+' Sets are build ');<br />
APA_Show_Process.ausgabe('Now select the set with lowest costs');<br />
{*********************************************************}<br />
{3. Berechne die Gesamtkosten für jedes Set}<br />
{*********************************************************}<br />
{Feststellen des besten Weges}<br />
{*********************}<br />
MyReqCubes:=TStringList.Create;<br />
MyMatCubes:=TStringList.Create;<br />
try<br />
//Lege alle nicht redundaten Cubes an, und vergib eine Nummer<br />
for zeile:=0 to anzzeilen-1 do begin<br />
for spalte:=0 to anzspalten-1 do begin<br />
if APA[spalte,zeile].farbe=clYellow then begin<br />
if APA[spalte,zeile].interessant=true then begin<br />
//Speichere Required Cubes<br />
//Merke dir die Required Cubes<br />
MyReqCubes.Add(auffuellen(inttostr(spalte),10)+auffuellen(inttostr(zeile),10));<br />
end;<br />
end;<br />
end;//end of spalte<br />
end;//end of zeilen<br />
merkcosts:=-1;merkpos:=-1;<br />
for zahler:=0 to MerkmatCubesfertig.Count-1 do begin<br />
NewStringList:=MerkmatCubesfertig.items[zahler];<br />
MyMatCubes.Clear;<br />
MyMatCubes.AddStrings(NewStringList);<br />
merkcosts2:=berechneKostenGesamt(MyMatCubes,MyReqCubes,true);<br />
Listbox1.Items.Add(inttostr(zahler)+' Kosten: '+floattostr(merkcosts2));<br />
listbox1.Items.Add('******************');<br />
APA_Show_Process.ausgabe('Set '+inttostr(zahler+1)+' has costs of<br />
'+floattostr(merkcosts2));<br />
- 338 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if (merkcosts=-1) or (merkcosts>merkcosts2) then begin<br />
Listbox1.items.add('Selected');<br />
merkpos:=zahler;<br />
merkcosts:=merkcosts2;<br />
end;<br />
end;//Ende zahler<br />
if MerkmatCubesfertig.count=0 then<br />
showmessage('The limit is to low. It is not possible to materialize a cube.');<br />
finally<br />
MyReqCubes.Free;<br />
MyMatCubes.Free;<br />
end;<br />
{*********************************************************}<br />
{Ende 3 Berechne die Gesamtkosten für jedes Set}<br />
{*********************************************************}<br />
{*********************************************************}<br />
{4. Materialisiere jenes Set mit den minimalen Kosten}<br />
{*********************************************************}<br />
if (merkpos-1)and(stop=false) then begin<br />
APA_Show_Process.ausgabe(inttostr(merkpos+1)+' sets minimizes the costs');<br />
NewStringList:=MerkMatCubesfertig.items[merkpos];<br />
for zahler:=0 to NewStringList.Count-1 do begin<br />
matcount:=matcount+1;<br />
end;<br />
end;<br />
APA[strtoint(copy(NewStringList[zahler],1,10)),strtoint(copy(NewStringList[zahler]<br />
,11,10))].materalisieren:=true;<br />
APA[strtoint(copy(NewStringList[zahler],1,10)),strtoint(copy(NewStringList[zahler]<br />
,11,10))].matcount:=matcount;<br />
{*********************************************************}<br />
{Ende 4 Materialisiere jenes Set mit den minimalen Kosten}<br />
{*********************************************************}<br />
finally<br />
Try<br />
//Freigeben der Daten<br />
for zahler:=0 to MerkMatCubes.Count-1 do begin<br />
NewStringList:=MerkMatCubes[zahler];<br />
NewStringList.Free;<br />
end;<br />
for zahler:=0 to MerkMatCubesfertig.Count-1 do begin<br />
NewStringList:=MerkMatCubesfertig[zahler];<br />
NewStringList.Free;<br />
end;<br />
MerkMatCubes.Free;<br />
MerkMatCubesfertig.Free;<br />
MatCubes.Free;<br />
PossibleCubes.Free;<br />
except<br />
end;<br />
end;<br />
finally<br />
APA_Grid.Enabled:=true;<br />
if APA_Show_Process.Visible=true then<br />
APA_Show_Process.ButtonCancel.Caption:='Close';<br />
CloseFile(fKosten);<br />
materialzeichnen;<br />
APAGrid.Repaint;<br />
showmessage('Ready');<br />
- 339 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
end;<br />
end;<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
procedure TAPA_Grid.APAGridClick(Sender: TObject);<br />
var counter:longint;<br />
var NewItem: TMenuItem;<br />
begin<br />
if (zellespalte-1) and(zellezeile-1) then begin<br />
klickspalte:=-1;<br />
klickzeile:=-1;<br />
if (Remove_Redundancy.Checked=false)or<br />
((Remove_Redundancy.Checked=true)and(APA[zellespalte,zellezeile].farbe=clYellow)) then<br />
begin;<br />
langbezpopup.Items.Clear;<br />
for counter:=0 to anzd-1 do begin;<br />
NewItem:=TMenuItem.Create(self);<br />
NewItem.Caption:=APA[zellespalte,zellezeile].langbez[counter];<br />
langbezpopup.Items.Add(NewItem);<br />
end;<br />
langbezpopup.Popup(Mouse.CursorPos.x,Mouse.CursorPos.Y);<br />
end;<br />
end;<br />
end;<br />
procedure TAPA_Grid.GridpopupPopup(Sender: TObject);<br />
var g:longint;<br />
begin<br />
if ((zellespalte-1)and(zellezeile-1))<br />
then begin;<br />
For g:=0 to Gridpopup.Items.Count-1 do Gridpopup.Items[g].Visible:=true;<br />
if Showpossiblecubes2.Visible=false then begin<br />
Showpossiblecubes1.Visible:=false;<br />
Removepossiblecubes1.Visible:=true;<br />
end else<br />
begin<br />
Showpossiblecubes1.Visible:=true;<br />
Removepossiblecubes1.Visible:=false;<br />
end;<br />
if Showdeterministicsolution2.Visible=false then begin<br />
Showdeterministicsolution1.Visible:=false;<br />
Removedeterministicsolution1.Visible:=true;<br />
end else begin<br />
Showdeterministicsolution1.Visible:=true;<br />
Removedeterministicsolution1.Visible:=false;<br />
end;<br />
if ((APA[zellespalte,zellezeile].farbe=clYellow)) then<br />
begin;<br />
NoCubeselected1.Visible:=false;<br />
Redundantcube1.Visible:=false;<br />
Showderivatives1.Visible:=true;<br />
Showredundancyfreecube1.Visible:=false;<br />
n3.Visible:=false;<br />
if APA[zellespalte,zellezeile].interessant=true then begin<br />
Required1.Visible:=false;Notrequired1.Visible:=true;<br />
end<br />
else<br />
begin<br />
Required1.Visible:=true;Notrequired1.Visible:=false;<br />
//Festlegen der Required Spalten<br />
for g:=0 to Required1.Count-1 do begin<br />
if g
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
end;<br />
Required1.Items[g].Visible:=true;<br />
Required1.Items[g].Caption:=APA_Parameter.APA_Degrees.Items[g];<br />
end else begin<br />
Required1.Items[g].Visible:=false;<br />
end;<br />
end;<br />
if APA[zellespalte,zellezeile].materalisieren=true then begin<br />
Materialize1.Visible:=false;Dematerialize1.Visible:=true;<br />
end<br />
else<br />
begin<br />
Materialize1.Visible:=true;Dematerialize1.Visible:=false;<br />
end;<br />
end else begin<br />
NoCubeselected1.Visible:=false;<br />
Redundantcube1.Visible:=true;n3.Visible:=true;<br />
Required1.Visible:=false;Notrequired1.Visible:=false;<br />
Materialize1.Visible:=false; Dematerialize1.Visible:=false;<br />
Showderivatives1.Visible:=false;<br />
Showredundancyfreecube1.Visible:=true;<br />
end;<br />
end else begin<br />
For g:=0 to Gridpopup.Items.Count-1 do Gridpopup.Items[g].Visible:=false;<br />
NoCubeselected1.Visible:=true;<br />
end;<br />
end;<br />
procedure TAPA_Grid.Removematerializedcubes1Click(Sender: TObject);<br />
begin<br />
Button_remove_materialized_cubes.Click;<br />
end;<br />
procedure TAPA_Grid.Removederivatives1Click(Sender: TObject);<br />
begin<br />
Button_remove_derivatives.Click;<br />
end;<br />
procedure TAPA_Grid.Removerequiredcubes1Click(Sender: TObject);<br />
begin<br />
Button_remove_required_cubes.Click;<br />
end;<br />
procedure TAPA_Grid.Removeredundancy1Click(Sender: TObject);<br />
begin<br />
if Remove_Redundancy.Checked=false then<br />
Remove_Redundancy.Checked:=true else<br />
Remove_Redundancy.checked:=false;<br />
Remove_RedundancyClick(self);<br />
end;<br />
procedure TAPA_Grid.Button3Click(Sender: TObject);<br />
var zeile,spalte, aktzeile,aktspalte:longint;<br />
var x,aktpos,maxpos,anzcube,reqcube, anzderivative,pos,cubepos:longint;<br />
var zahler, zahler2:longint;<br />
var istok:boolean;<br />
var ende:boolean;<br />
var kostenmerk,Kostenmerkmin:Extended;<br />
var neustarten, Alwaysspacemaxreached:boolean;<br />
var Countliste:array of Longint;<br />
var GeneriereListe,GeneriereReqListe:TStringList;<br />
begin<br />
assignfile(fMatCubes,'C:\APADIR\DATA\MatCubes.dat');<br />
assignfile(fReqCubes,'C:\APADIR\DATA\ReqCubes.dat');<br />
assignfile(fMerkkosten,'C:\APADIR\DATA\Merkkosten.dat');<br />
assignfile(fCounter,'C:\APADIR\DATA\Counter.dat');<br />
assignfile(fCountermerk,'C:\APADIR\DATA\Countermerk.dat');<br />
- 341 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
assignfile(fCubes,'C:\APADIR\DATA\Cubes.dat');<br />
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');<br />
{$i-}<br />
reset(fKosten);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('cost database error ');exit;end;<br />
assignfile(fCubes,'C:\APADIR\DATA\Cubes.dat');<br />
Removedeterministicsolution1Click(self);<br />
mustsave:=true;<br />
APA_Show_Process.show;<br />
Application.ProcessMessages;<br />
APA_Grid.Enabled:=false;<br />
GeneriereReqListe:=TStringList.Create();<br />
try<br />
{Rechne alle möglichen Kombinationen durch, welche im Bereich des Maximum sind}<br />
// Mache das über eine Temporäre Datei auf der Festplatte<br />
// ist zwar langsamer, aber bei großen Rechnungen hängt sich der Rechner nicht auf.<br />
with APA_Application do begin<br />
APA_Dialog.APA_Text.Caption:='Do you want to restart?';<br />
if permutation=true then begin<br />
if APA_Dialog.showmodal=mryes then<br />
neustarten:=true else neustarten:=false;<br />
end else neustarten:=true;<br />
{1. Vorbereitungen für die Permutation}<br />
aktpos:=0;permutation:=true;<br />
if neustarten=true then begin;<br />
alwaysspacemaxreached:=false;<br />
{$i-}<br />
rewrite(fCubes);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('Cubes database error ');exit;end;<br />
{$i-}<br />
rewrite(fReqCubes);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('ReqCubes database error ');exit;end;<br />
{$i-}<br />
rewrite(fCounter);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('Counter database error ');exit;end;<br />
{$i-}<br />
rewrite(fMerkkosten);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('ReqCubes database error ');exit;end;<br />
try<br />
seek(fMerkkosten,0);<br />
vMerkkosten.Lfnr:=0;<br />
vMerkkosten.Kosten:=0;<br />
write(fMerkkosten,vMerkkosten);<br />
APA_Show_Process.ausgabe('Search for possible cubes...');<br />
anzcube:=0; reqcube:=0;<br />
//Lege alle nicht redundaten Cubes an, und vergib eine Nummer<br />
for zeile:=0 to anzzeilen-1 do begin<br />
for spalte:=0 to anzspalten-1 do begin<br />
if APA[spalte,zeile].farbe=clYellow then begin<br />
if APA[spalte,zeile].interessant=True then begin<br />
anzcube:=anzcube+1;<br />
seek(fCubes,anzcube-1);<br />
- 342 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
vCubes.Lfnr:=anzcube;<br />
vCubes.Spalte:=spalte;<br />
vCubes.Zeile:=zeile;<br />
vCubes.Required:=1;<br />
write(fCubes,vCubes);<br />
APA_Show_Process.ausgabe('Add Cube:<br />
('+inttostr(spalte)+':'+inttostr(zeile)+')');<br />
end else begin<br />
anzderivative:=0;<br />
for aktzeile:=0 to anzzeilen-1 do begin<br />
for aktspalte:=0 to anzspalten-1 do begin<br />
if (APA[aktspalte,aktzeile].farbe=clYellow)and<br />
(APA[aktspalte,aktzeile].interessant=true) then begin<br />
if isderivat(spalte,zeile,aktspalte,aktzeile) then begin<br />
anzderivative:=anzderivative+1;<br />
end;<br />
end;<br />
end;<br />
end;<br />
if anzderivative>0 then begin<br />
anzcube:=anzcube+1;<br />
seek(fCubes,anzcube-1);<br />
vCubes.Lfnr:=anzcube;<br />
vCubes.Spalte:=spalte;<br />
vCubes.Zeile:=zeile;<br />
vCubes.Required:=1;<br />
write(fCubes,vCubes);<br />
APA_Show_Process.ausgabe('Add Cube:<br />
('+inttostr(spalte)+':'+inttostr(zeile)+')');<br />
end;<br />
end;<br />
if APA[spalte,zeile].interessant=true then begin<br />
//Speichere Required Cubes<br />
//Merke dir die Required Cubes<br />
reqcube:=reqcube+1;<br />
seek(fReqCubes,reqcube-1);<br />
vReqCubes.Lfnr:=reqcube;<br />
vReqCubes.Spalte:=spalte;<br />
vReqCubes.Zeile:=zeile;<br />
write(fReqCubes,vReqCubes);<br />
end;<br />
end;<br />
end;//end of spalte<br />
end;//end of zeilen<br />
finally<br />
CloseFile(fCubes);<br />
CloseFile(fReqCubes);<br />
CloseFile(fCounter);<br />
CloseFile(fMerkkosten);<br />
end;<br />
end//von neustarten<br />
else begin<br />
alwaysspacemaxreached:=false;<br />
end;<br />
try<br />
{$i-}<br />
reset(fCubes);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('Cubes database error ');exit;end;<br />
anzcube:=filesize(fCubes);<br />
Setlength(Countliste,anzcube);<br />
MemoryCubes:=nil;<br />
- 343 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
setlength(MemoryCubes,anzcube);<br />
pos:=0;<br />
repeat;<br />
if (filesize(fCubes)>0) then begin<br />
seek(fCubes,pos);<br />
read(fCubes,vCubes);<br />
x:=round(vCubes.lfnr)-1;<br />
Memorycubes[x].nr:=round(vCubes.lfnr);<br />
Memorycubes[x].spalte:=vCubes.Spalte;<br />
Memorycubes[x].zeile:=vCubes.Zeile;<br />
end;<br />
pos:=pos+1;<br />
until pos>=filesize(fCubes);<br />
{$i-}<br />
reset(fReqCubes);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('ReqCubes database error ');exit;end;<br />
try<br />
MemoryreqCubes:=nil;<br />
setlength(MemoryReqCubes,filesize(fReqCubes));<br />
MemoryReqCubescount:=filesize(fReqCubes);<br />
pos:=0;<br />
repeat;<br />
if (filesize(fReqCubes)>0) then begin<br />
seek(fReqCubes,pos);<br />
read(fReqCubes,vReqCubes);<br />
x:=round(vReqCubes.Lfnr)-1;<br />
MemoryReqCubes[x].spalte:=vReqCubes.Spalte;<br />
MemoryReqCubes[x].zeile:=vReqCubes.Zeile;<br />
end;<br />
pos:=pos+1;<br />
until (pos>=filesize(fReqCubes));<br />
for x:=0 to MemoryReqCubescount-1 do begin<br />
GeneriereReqListe.Add(auffuellen(inttostr(MemoryReqCubes[x].spalte),10)+auffuellen<br />
(inttostr(MemoryReqCubes[x].zeile),10));<br />
end;<br />
APA_Show_Process.ausgabe(inttostr(anzcube)+' Cubes found');<br />
finally<br />
CloseFile(fReqCubes);<br />
end;<br />
finally<br />
CloseFile(fCubes);<br />
end;<br />
Countliste:=nil;<br />
Setlength(Countliste,anzcube+1);<br />
MerkeListe:=nil;<br />
SetLength(Merkeliste,anzcube);<br />
if neustarten=true then begin<br />
//Zuerst alle 0 setzten<br />
for x:=0 to anzcube-1 do Countliste[x]:=0;<br />
maxpos:=0;<br />
Countliste[0]:=1;<br />
cubepos:=Countliste[0];<br />
kostenmerkmin:=0;<br />
end// of neustarten<br />
else begin<br />
for x:=0 to anzcube-1 do Countliste[x]:=0;<br />
- 344 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
try<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
//Laden der Cubes<br />
{$i-}<br />
reset(fCounter);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('ReqCubes database error ');exit;end;<br />
maxpos:=-1;pos:=0;<br />
repeat;<br />
if (filesize(fCounter)>0) then begin<br />
seek(fCounter,pos);<br />
read(fCounter,vCounter);<br />
if vcounter.Lfnr-1 then begin<br />
maxpos:=maxpos+1;<br />
x:=round(vCounter.Lfnr);<br />
Countliste[x]:=round(vCounter.nr);<br />
if countliste[x]=0 then countliste[x]:=1;<br />
end;<br />
end else begin<br />
//Feststellen von alwaysspacemaxreached<br />
if vcounter.nr=1 then<br />
alwaysspacemaxreached:=true else<br />
alwaysspacemaxreached:=false;<br />
end;<br />
pos:=pos+1;<br />
until pos>=filesize(fCounter);<br />
cubepos:=Countliste[0]<br />
finally<br />
CloseFile(fCounter);<br />
end;<br />
end;<br />
{$i-}<br />
reset(fMerkkosten);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('Merkkosten database error ');exit;end;<br />
try<br />
seek(fMerkkosten,0);read(fMerkkosten,vMerkkosten);<br />
kostenmerkmin:=vMerkkosten.Kosten;<br />
finally<br />
CloseFile(fMerkkosten);<br />
end;<br />
{Ende 1. Vorbereitungen für die Permutation}<br />
if anzcube>0 then begin<br />
//Kombinatorik<br />
if neustarten=true then begin<br />
Countliste[0]:=1;<br />
aktpos:=0;maxpos:=0;<br />
end//neustarten<br />
else APA_Show_Process.ausgabe('*** Start Restart ***');<br />
{2. Beginn der Permutationsschleife}<br />
ende:=false;<br />
while (ende=false)and (stop=false) do begin<br />
repeat;<br />
Application.processmessages;<br />
if APA_Show_Process.GroupBox1.tag=1 then begin<br />
APA_Show_Process.GroupBox1.tag:=0;<br />
//Geheimticker<br />
for x:=0 to maxpos do begin<br />
- 345 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
countliste[x]:=1;<br />
end;<br />
maxpos:=maxpos+1;<br />
countliste[maxpos]:=1;<br />
end;<br />
if APA_Show_Process.GroupBox1.tag=-1 then begin<br />
APA_Show_Process.GroupBox1.tag:=0;<br />
//Geheimticker<br />
countliste[maxpos]:=0;<br />
maxpos:=maxpos-1;<br />
for x:=0 to maxpos do begin<br />
countliste[x]:=1;<br />
end;<br />
end;<br />
//Hüpfe nach links, wenn möglich<br />
// ausser bei Cube max dann nach rechts<br />
if cubepos>anzcube then begin<br />
//Hüpfe nach rechts<br />
//Speichere aktuelle Pos<br />
cubepos:=1;<br />
Countliste[aktpos]:=cubepos;<br />
aktpos:=aktpos+1;<br />
if aktpos>maxpos then maxpos:=aktpos;<br />
if aktposanzcube then begin<br />
cubepos:=1;<br />
Countliste[aktpos]:=cubepos;<br />
aktpos:=aktpos+1;<br />
if aktpos>maxpos then maxpos:=aktpos;<br />
end;<br />
if Countliste[aktpos]=0 then begin<br />
//Neue Zählung<br />
if (alwaysspacemaxreached=true)and(Alwaysspacemaxbeachten1.Checked=true) then<br />
ende:=true;<br />
cubepos:=1;<br />
Countliste[aktpos]:=cubepos;<br />
alwaysspacemaxreached:=true;<br />
end else begin<br />
//Springe auf gespeicherte Position<br />
Countliste[aktpos]:=Countliste[aktpos]+1;<br />
cubepos:=Countliste[aktpos];<br />
end;<br />
until (cubepos50000 then<br />
APA_Show_Process.APA_Protocoll.Items.Clear;<br />
if stop=true then stop:=false;<br />
//Hier soll nicht abgebrochen werden<br />
end//von
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
//Es wird von der Position bis zum Ende kontrolliert<br />
//da die ersten Positionen schon verglichen wurden<br />
for zahler2:=zahler to maxpos do begin<br />
if ((zahler2zahler)and<br />
(Countliste[zahler2]=Countliste[zahler]))<br />
then<br />
istok:=false;<br />
end;<br />
end;<br />
if istok=true then begin<br />
//Speichern<br />
//Stelle fest ob spacemax erfüllt.<br />
//Wenn ja berechne Kosten<br />
spaceleftfirstcubes:=strtofloat(APA_Parameter.APA_Thomas_spacemax.text);<br />
spaceleft:=strtofloat(APA_Parameter.APA_Thomas_spacemax.text);<br />
for x:=0 to maxpos do begin<br />
APA_Show_Process.ausgabe(' '+inttostr(countliste[x]));<br />
if countliste[x]>0 then begin<br />
spaceleft:=spaceleft-<br />
(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(MemoryCubes[Coun<br />
tliste[x]-1].spalte,MemoryCubes[Countliste[x]-1].zeile));<br />
if x0 then begin<br />
//Rechne den Speicherplatz ohne die letzte Ebene aus.<br />
//Wenn dieser überschritten kann der durchlauf der letzten Ebene gestoppt werden<br />
spaceleftfirstcubes:=spaceleftfirstcubes-<br />
(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(MemoryCubes[Coun<br />
tliste[x]-1].spalte,MemoryCubes[Countliste[x]-1].zeile));<br />
end;<br />
end;<br />
end;//Ende von x<br />
//Wenn überschritten setzt den Zähler der ersten auf max<br />
if (spaceleftfirstcubes0 then begin<br />
GeneriereListe:=TStringList.create();<br />
try<br />
for x:=0 to maxpos do begin<br />
if countliste[x]>0 then begin<br />
GeneriereListe.Add(auffuellen(inttostr(MemoryCubes[countliste[x]-<br />
1].spalte),10)+auffuellen(inttostr(MemoryCubes[countliste[x]-1].zeile),10));<br />
end;<br />
end;<br />
kostenmerk:=berechneKostenGesamt(GeneriereListe,GeneriereReqListe,true);<br />
finally<br />
GeneriereListe.Free;<br />
end;<br />
if kostenmerk>0 then begin<br />
- 347 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if(kostenmerkmin=0)or(kostenmerkmin>kostenmerk)<br />
then begin;<br />
Alwaysspacemaxreached:=false;<br />
{$i-}<br />
reset(fMerkkosten);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('Merkkosten database error ');exit;end;<br />
try<br />
APA_Show_Process.ausgabe('*****************');<br />
APA_Show_Process.ausgabe('Trage ein das Minimum '+floattostr(kostenmerk));<br />
vMerkkosten.Kosten:=kostenmerk;<br />
vMerkkosten.Lfnr:=0;<br />
seek(fMerkkosten,0);write(fMerkkosten,vMerkkosten);<br />
kostenmerkmin:=kostenmerk;<br />
seek(fMerkkosten,1);<br />
vMerkkosten.Lfnr:=1;<br />
vMerkkosten.Kosten:=spaceleft;<br />
write(fMerkkosten,vMerkkosten);<br />
seek(fMerkkosten,2);<br />
vMerkkosten.Lfnr:=2;<br />
vMerkkosten.Kosten:=timeleft;<br />
write(fMerkkosten,vMerkkosten);<br />
finally<br />
CloseFile(fMerkkosten);<br />
end;<br />
//Speichere Counttable<br />
assignfile(fCountermerk,'c:\APADIR\DATA\Countermerk.dat');<br />
{$i-}<br />
rewrite(fCountermerk);<br />
{$i+}<br />
if ioresult0 then showmessage('Can not open File Countermerk.dat');<br />
try<br />
for x:=0 to maxpos do begin<br />
seek(fCountermerk,filesize(fCountermerk));<br />
vCountermerk.Lfnr:=x;<br />
vCountermerk.Nr:=Countliste[x];<br />
write(fCountermerk,vCountermerk);<br />
APA_Show_Process.ausgabe('Save Cube Pos:'+floattostr(vCountermerk.Lfnr)+'<br />
Nr:'+floattostr(vCountermerk.Nr));<br />
end;<br />
finally<br />
CloseFile(Fcountermerk);<br />
end;<br />
end;<br />
end else APA_Show_Process.ausgabe('Ist O ');<br />
end// spaceleft>0<br />
else APA_Show_Process.ausgabe('spacemax reached ');<br />
end;//of istok<br />
cubepos:=cubepos+1;<br />
Countliste[aktpos]:=cubepos;<br />
end;//Ende von links<br />
repeat; Application.ProcessMessages; until break=false;<br />
if (stop=true) and (aktpos0) then stop:=false;<br />
//Nur in der aktpos stoppen<br />
until (cubepos>anzcube)or (stop=true);<br />
if (stop=true) and (aktpos0) then stop:=false;<br />
//Nur in der aktpos stoppen<br />
end;//ende=true;<br />
- 348 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
{Ende 2. Beginn der Permutationsschleife}<br />
//Speichern des aktuellen Cubeliste damit man wieder weiter machen kann.<br />
//speichere aktuelle Position<br />
assignfile(fCounter,'c:\APADIR\DATA\Counter.dat');<br />
{$i-}<br />
rewrite(fCounter);<br />
{$i+}<br />
if ioresult0 then showmessage('Can not open File Counter.dat');<br />
try<br />
seek(fCounter,0);<br />
vCounter.Lfnr:=-1;<br />
if vcounter.nr=1 then<br />
if alwaysspacemaxreached=true then vcounter.Nr:=1<br />
else vcounter.Nr:=0;<br />
write(fCounter,vCounter);<br />
for x:=0 to maxpos do begin<br />
seek(fCounter,x+1);<br />
vCounter.Lfnr:=x;<br />
vCounter.Nr:=Countliste[x];<br />
write(fCounter,vCounter);<br />
end;<br />
finally<br />
CloseFile(fcounter);<br />
end;<br />
end;// Wenn es mindestens einen Cube gibt in der Cubeliste<br />
end;//with Apa_Application<br />
finally<br />
CloseFile(fKosten);<br />
GeneriereReqListe.Free;<br />
Showmessage('Ready');<br />
APA_Grid.Enabled:=true;<br />
end;<br />
end;<br />
procedure TAPA_Grid.Algorithm1Click(Sender: TObject);<br />
begin<br />
if permutation=true then begin<br />
Button3.click;<br />
end else begin<br />
APA_Dialog.APA_Text.Caption:='Your last deterministic run was not a permutation. Do<br />
you want do continue? This will delete your last run!';<br />
end;<br />
end;<br />
if APA_Dialog.showmodal=mryes then begin;<br />
Button3.Click;<br />
end;<br />
procedure TAPA_Grid.SearchusingThomasAchsheuristic2Click(Sender: TObject);<br />
begin<br />
Button2.click;<br />
end;<br />
procedure TAPA_Grid.Alogrithm1Click(Sender: TObject);<br />
begin<br />
Button3.Click;<br />
end;<br />
procedure TAPA_Grid.Parameter1Click(Sender: TObject);<br />
begin<br />
APA_Parameter.ShowModal;<br />
end;<br />
function TAPA_Grid.berechneKostenGesamt(MatCubes,ReqCubes:TStringList;<br />
Nullstellen:boolean):Extended;<br />
var x,aktspalte,aktzeile:longint;<br />
var SummeKosten:Extended;<br />
- 349 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
var zahler,counter:longint;<br />
var newcosts:Extended;<br />
var new:String;<br />
var isderivatof:boolean;<br />
var newminderivatspalte,newminderivatzeile:longint;<br />
var spalte,zeile:longint;<br />
begin<br />
// Berechne die Materialisierungskosten<br />
spaceleft:=strtofloat(APA_Parameter.APA_Thomas_spacemax.text);<br />
timeleft:=strtofloat(APA_Parameter.APA_Thomas_timemax.text);<br />
Memorywuerfel:= TStringList.Create; //Erzeuge die Liste der ausgewählten Würfel<br />
SummeKosten:=0;<br />
try<br />
for x:=0 to MatCubes.count-1 do begin<br />
aktspalte:=strtoint(copy(MatCubes[x],1,10));<br />
aktzeile:=strtoint(copy(MatCubes[x],11,10));<br />
spaceleft:=spaceleft-<br />
(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(aktspalte,aktzei<br />
le));<br />
end;//Ende von x<br />
if (spaceleft>0) then begin<br />
//2. Kosten der Kombination berechnen<br />
SummeKosten:=0;<br />
//2A Ersten Würfel zusetzen<br />
aktspalte:=strtoint(copy(MatCubes[0],1,10));<br />
aktzeile:=strtoint(copy(MatCubes[0],11,10));<br />
if (Userandomcosts1.Checked=true) then begin<br />
newcosts:=getbuild(-1,-1,aktspalte,aktzeile);<br />
end else begin<br />
newcosts:=deltaBftW(aktspalte,aktzeile,false);<br />
end;<br />
SummeKosten:=SummeKosten+newcosts;<br />
new:=auffuellen(inttostr(aktspalte),30);<br />
new:=new+auffuellen(inttostr(aktzeile),30);<br />
Memorywuerfel.Add(new);<br />
listbox1.Items.Add('Add '+new+' build from BFT');<br />
listbox1.Items.Add('that costs '+floattostr(newcosts));<br />
timeleft:=timeleft-newcosts;<br />
//Erster Würfel zugesetzt Ende<br />
//2B Zusätzlich Würfel zusetzen<br />
for x:=1 to MatCubes.count-1 do begin<br />
aktspalte:=strtoint(copy(MatCubes[x],1,10));<br />
aktzeile:=strtoint(copy(MatCubes[x],11,10));<br />
//? Kann der neue Würfel aus einem bereits materialisierten Würfel abgeleitet<br />
werden?<br />
isderivatof:=false;<br />
for counter:=0 to Memorywuerfel.count-1 do begin<br />
New:=Memorywuerfel[counter];<br />
if<br />
isderivat(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),<br />
aktspalte,aktzeile) then begin;<br />
isderivatof:=true;<br />
end;<br />
end;<br />
if isderivatof=true then begin<br />
//Yes leite aus diesem Würfel ab<br />
newminderivatspalte:=GetMinDerivatOfSpalte(aktspalte,aktzeile,false);<br />
newminderivatzeile:=GetMinDerivatOfZeile(aktspalte,aktzeile,false);<br />
- 350 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if (Userandomcosts1.Checked=true) then begin<br />
newcosts:=getbuild(newminderivatspalte,newminderivatzeile,<br />
aktspalte,aktzeile);<br />
end else begin<br />
newcosts:=deltaVW(newminderivatspalte,newminderivatzeile,<br />
aktspalte,aktzeile,false);<br />
end;<br />
SummeKosten:=SummeKosten+newcosts;<br />
new:=auffuellen(inttostr(aktspalte),30);<br />
new:=new+auffuellen(inttostr(aktzeile),30);<br />
listbox1.Items.Add('Add '+new+' build from ('+<br />
inttostr(newminderivatspalte)+':'+<br />
inttostr(newminderivatzeile)+')');<br />
listbox1.Items.Add('that costs '+<br />
floattostr(newcosts));<br />
Memorywuerfel.Add(new);<br />
if Userandomcosts1.Checked=true then begin<br />
timeleft:=timeleft-newcosts;<br />
end else<br />
begin<br />
timeleft:=timeleft-<br />
(strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(gettupel(newminderivatspalte,ne<br />
wminderivatzeile)+(2*gettupel(aktspalte,aktzeile)))+<br />
+strtofloat(APA_Parameter.APA_Thomas_timecpu.text)*gettupel(aktspalte,aktzeile)*lo<br />
g2(gettupel(aktspalte,aktzeile))+<br />
strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*gettupel(aktspalte,aktzeile));<br />
end;<br />
end else begin<br />
//No leite aus dem BFT ab<br />
if (Userandomcosts1.Checked=true) then begin<br />
newcosts:=getbuild(-1,-1,aktspalte,aktzeile);<br />
end else begin<br />
newcosts:=deltaBftW(aktspalte,aktzeile,false);<br />
end;<br />
SummeKosten:=SummeKosten+newcosts;<br />
new:=auffuellen(inttostr(aktspalte),30);<br />
new:=new+auffuellen(inttostr(aktzeile),30);<br />
listbox1.Items.Add('Add '+new+' build from BFT');<br />
listbox1.Items.Add('that costs '+floattostr(newcosts));<br />
Memorywuerfel.Add(new);<br />
if Userandomcosts1.Checked=true then begin<br />
timeleft:=timeleft-newcosts;<br />
end else begin<br />
timeleft:=timeleft-(strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(gettupel(-<br />
1,-1)+(2*gettupel(aktspalte,aktzeile)))+<br />
+strtofloat(APA_Parameter.APA_Thomas_timecpu.text)*gettupel(aktspalte,aktzeile)*lo<br />
g2(gettupel(aktspalte,aktzeile))+<br />
strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*gettupel(aktspalte,aktzeile));<br />
end;<br />
end;<br />
end;//Ende von x<br />
Listbox1.Items.Add('Die Würfel sind');<br />
for counter:=0 to Memorywuerfel.Count-1 do begin<br />
Listbox1.Items.add(Memorywuerfel[counter]);<br />
end;<br />
{zahler:=0; EntferneausDiss<br />
repeat;<br />
If MatCubes.count>zahler then begin<br />
//Merke Ausgangscube<br />
merkcube:=zahler;<br />
merkspalte:=strtoint(copy(MatCubes[zahler],1,10));<br />
merkzeile:=strtoint(copy(MatCubes[zahler],11,10));<br />
- 351 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
//Kontrolliere alle Vorgänger des aktuellen Cube<br />
zahler2:=0;<br />
merkderivat:=-1;merkderivatspalte:=-1;merkderivatzeile:=-1;<br />
repeat;<br />
if (MatCubes.count>zahler2) then begin<br />
if<br />
((strtoint(copy(MatCubes[zahler2],1,10))merkspalte)or(strtoint(copy(MatCubes[zah<br />
ler2],11,10))merkzeile))<br />
and(merkcube>zahler2)//Verhindert, dass nur Cubes, welche früher mat. wurden<br />
beachtet werden<br />
then begin<br />
if<br />
(isderivat(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],<br />
11,10)),<br />
merkspalte,merkzeile)=true)<br />
then begin;<br />
//Wenn kosten kleiner als bereits gemerkter dann merken<br />
if (Userandomcosts1.Checked=true) then begin<br />
if (merkderivat=-1) or (<br />
(getbuild(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],1<br />
1,10)),<br />
merkspalte,merkzeile)<<br />
getbuild(merkderivatspalte,merkderivatzeile,merkspalte,merkzeile)))<br />
then begin<br />
merkderivat:=zahler2;<br />
merkderivatspalte:=strtoint(copy(MatCubes[zahler2],1,10));<br />
merkderivatzeile:= strtoint(copy(MatCubes[zahler2],11,10));<br />
end;<br />
end else begin<br />
if (merkderivat=-1) or (<br />
(deltaVW(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],11<br />
,10)),<br />
merkspalte,merkzeile,false)<<br />
deltaVW(merkderivatspalte,merkderivatzeile,merkspalte,merkzeile,false)))<br />
then begin<br />
merkderivat:=zahler2;<br />
merkderivatspalte:=strtoint(copy(MatCubes[zahler2],1,10));<br />
merkderivatzeile:= strtoint(copy(MatCubes[zahler2],11,10));<br />
end;<br />
end;<br />
end;<br />
end;//spaltespalte oder zeilezeile<br />
end; //Lfnr<br />
zahler2:=zahler2+1;<br />
until (zahler2>MatCubes.count-1)or(zahler2=merkcube);<br />
//Wenn derivat vorhanden erzeuge aus dem Derivat sonst aus BFT<br />
if merkderivat-1 then begin<br />
if (Userandomcosts1.Checked=true) then begin<br />
merkcosts:=getbuild(merkderivatspalte,merkderivatzeile,strtoint(copy(MatCubes[zahl<br />
er],1,10)),strtoint(copy(MatCubes[zahler],11,10)));<br />
end else begin<br />
merkcosts:=deltaVW(merkderivatspalte,merkderivatzeile,strtoint(copy(MatCubes[zahle<br />
r],1,10)),strtoint(copy(MatCubes[zahler],11,10)),false);<br />
end;<br />
SummeKosten:=SummeKosten+merkcosts;<br />
listbox1.Items.Add('Add<br />
'+inttostr(strtoint(copy(MatCubes[zahler],1,10)))+':'+inttostr(strtoint(copy(MatCu<br />
bes[zahler],11,10)))+' erzeugt aus '+<br />
inttostr(merkderivatspalte)+':'+inttostr(merkderivatzeile));<br />
listbox1.Items.Add('costs are '+floattostr(merkcosts));<br />
//Berechne spaceleft und timeleft<br />
- 352 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if (Userandomcosts1.Checked=false) then begin<br />
timeleft:=timeleft-(strtofloat(APA_Parameter.APA_Thomas_timeio.text)*<br />
(gettupel(-1,-<br />
1)+(2*gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler<br />
],11,10)))))+<br />
+strtofloat(APA_Parameter.APA_Thomas_timecpu.text)*<br />
gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler],11,1<br />
0)))<br />
*log2(gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler<br />
],11,10))))+<br />
strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*<br />
gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler],11,1<br />
0))));<br />
spaceleft:=spaceleft-<br />
(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*<br />
gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler],11,1<br />
0))));<br />
end else begin<br />
timeleft:=timeleft-<br />
merkcosts;<br />
spaceleft:=spaceleft-<br />
(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*<br />
gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler],11,1<br />
0))));<br />
end;<br />
end else begin<br />
if (Userandomcosts1.Checked=true) then begin<br />
merkcosts:=getbuild(-1,-<br />
1,strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler],11,10)));<br />
end else begin<br />
merkcosts:=deltaBftW(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[<br />
zahler],11,10)),false);<br />
end;<br />
SummeKosten:=SummeKosten+merkcosts;<br />
listbox1.Items.Add('Add<br />
'+inttostr(strtoint(copy(MatCubes[zahler],1,10)))+':'+inttostr(strtoint(copy(MatCu<br />
bes[zahler],11,10)))+' erzeugt aus '+<br />
inttostr(-1)+':'+inttostr(-1));<br />
listbox1.Items.Add('costs are '+floattostr(merkcosts));<br />
if (Userandomcosts1.Checked=false) then begin<br />
timeleft:=timeleft-(strtofloat(APA_Parameter.APA_Thomas_timeio.text)*<br />
(gettupel(-1,-<br />
1)+(2*gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler<br />
],11,10)))))+<br />
+strtofloat(APA_Parameter.APA_Thomas_timecpu.text)*<br />
gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler],11,1<br />
0)))<br />
*log2(gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler<br />
],11,10))))+<br />
strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*<br />
- 353 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler],11,1<br />
0))));<br />
spaceleft:=spaceleft-<br />
(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*<br />
gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler],11,1<br />
0))));<br />
end else begin<br />
timeleft:=timeleft-<br />
merkcosts;<br />
spaceleft:=spaceleft-<br />
(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*<br />
gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler],11,1<br />
0))));<br />
end;<br />
end;<br />
end;<br />
zahler:=zahler+1;<br />
until (zahler>MatCubes.count-1);}<br />
//3. Berechne die Abfragekosten<br />
{zahler:=0; //Zahler für ReqCubes<br />
repeat;<br />
if (zahler
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
deltaVW(merkderivatspalte,merkderivatzeile,strtoint(copy(ReqCubes[zahler],1,10)),s<br />
trtoint(copy(ReqCubes[zahler],11,10)),false)))<br />
then begin<br />
end;<br />
end;<br />
end;<br />
merkderivat:=zahler2;<br />
merkderivatspalte:=strtoint(copy(MatCubes[zahler2],1,10));<br />
merkderivatzeile:= strtoint(copy(MatCubes[zahler2],11,10));<br />
end;<br />
zahler2:=zahler2+1;<br />
until (zahler2>MatCubes.count-1);<br />
aktspalte:=strtoint(copy(ReqCubes[zahler],1,10));<br />
aktzeile:=strtoint(copy(ReqCubes[zahler],11,10));<br />
if merkderivat=-1 then begin<br />
//Erzeuge aus BFT<br />
if (Userandomcosts1.Checked=true) then begin<br />
SummeKosten:=SummeKosten+<br />
(getquery(-1,-1,aktspalte,aktzeile)*<br />
APA[aktspalte,aktzeile].gewicht);<br />
listbox1.Items.Add('Query '+inttostr(aktspalte)+':'+inttostr(aktzeile)+'<br />
erzeugt aus '+<br />
inttostr(-1)+':'+inttostr(-1));<br />
listbox1.Items.Add('costs are '+floattostr((getquery(-1,-<br />
1,aktspalte,aktzeile)*<br />
APA[aktspalte,aktzeile].gewicht)));<br />
end else begin<br />
SummeKosten:=SummeKosten+<br />
(deltaBftW(aktspalte,aktzeile,true)*<br />
APA[aktspalte,aktzeile].gewicht);<br />
listbox1.Items.Add('Query '+inttostr(aktspalte)+':'+inttostr(aktzeile)+'<br />
erzeugt aus '+<br />
inttostr(-1)+':'+inttostr(-1));<br />
listbox1.Items.Add('costs are<br />
'+floattostr((deltaBftW(aktspalte,aktzeile,true)*<br />
APA[aktspalte,aktzeile].gewicht)));<br />
end;<br />
end else begin<br />
//Erzeuge aus dem Derivat<br />
if (Userandomcosts1.Checked=true) then begin<br />
SummeKosten:=SummeKosten+<br />
(getquery(merkderivatspalte,merkderivatzeile,aktspalte,aktzeile)*<br />
APA[aktspalte,aktzeile].gewicht);<br />
end;<br />
end;<br />
listbox1.Items.Add('Query '+inttostr(aktspalte)+':'+inttostr(aktzeile)+' erzeugt<br />
aus '+<br />
inttostr(merkderivatspalte)+':'+inttostr(merkderivatzeile));<br />
listbox1.Items.Add('costs are<br />
'+floattostr((getquery(merkderivatspalte,merkderivatzeile,aktspalte,aktzeile)*<br />
APA[aktspalte,aktzeile].gewicht)));<br />
end else begin<br />
SummeKosten:=SummeKosten+<br />
(deltaVW(merkderivatspalte,merkderivatzeile,aktspalte,aktzeile,true)*<br />
APA[aktspalte,aktzeile].gewicht);<br />
listbox1.Items.Add('Query '+inttostr(aktspalte)+':'+inttostr(aktzeile)+' erzeugt<br />
aus '+<br />
inttostr(merkderivatspalte)+':'+inttostr(merkderivatzeile));<br />
listbox1.Items.Add('costs are<br />
'+floattostr((deltaVW(merkderivatspalte,merkderivatzeile,aktspalte,aktzeile,true)*<br />
APA[aktspalte,aktzeile].gewicht)));<br />
end;<br />
- 355 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
zahler:=zahler+1;<br />
until (zahler>ReqCubes.count-1); }<br />
{3.Zusetzen der Querykosten}<br />
for zahler:=0 to ReqCubes.count-1 do begin;<br />
spalte:=strtoint(copy(ReqCubes[zahler],1,10));<br />
zeile:=strtoint(copy(ReqCubes[zahler],11,10));<br />
isderivatof:=false;<br />
for counter:=0 to Memorywuerfel.Count-1 do begin<br />
New:=Memorywuerfel[counter];<br />
if<br />
isderivat(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),<br />
spalte,zeile) then begin;<br />
isderivatof:=true;<br />
end;<br />
end;<br />
if isderivatof=true then begin<br />
newminderivatspalte:=GetMinDerivatOfSpalte(spalte,zeile,true);<br />
newminderivatzeile:=GetMinDerivatOfZeile(spalte,zeile,true);<br />
if (Userandomcosts1.Checked=true) then begin<br />
newcosts:= ((getquery(newminderivatspalte,newminderivatzeile,<br />
spalte,zeile))<br />
*APA[spalte,zeile].gewicht);<br />
end else begin<br />
newcosts:= ((deltaVW(newminderivatspalte,newminderivatzeile,<br />
spalte,zeile,true))<br />
*APA[spalte,zeile].gewicht);<br />
end;<br />
SummeKosten:=SummeKosten+newcosts;<br />
listbox1.Items.Add('Reqcosts ('+inttostr(spalte)+':'+inttostr(zeile)+')');<br />
Listbox1.items.add('Query from ('+inttostr(newminderivatspalte)+':'+<br />
inttostr(newminderivatzeile)+')');<br />
listbox1.Items.Add('that costs '+floattostr(newcosts));<br />
end else begin<br />
if (Userandomcosts1.Checked=true) then begin<br />
newcosts:=((getquery(-1,-1,spalte,zeile))<br />
*APA[spalte,zeile].gewicht);<br />
end else begin<br />
newcosts:=((deltaBftW(spalte,zeile,true))<br />
*APA[spalte,zeile].gewicht);<br />
end;<br />
SummeKosten:=SummeKosten+ newcosts;<br />
listbox1.Items.Add('Reqcosts ('+inttostr(spalte)+':'+inttostr(zeile)+')');<br />
Listbox1.Items.Add('Query from BFT');<br />
listbox1.Items.Add('that costs '+floattostr(newcosts));<br />
end;<br />
end;//of zahler<br />
if (timeleft0<br />
finally<br />
Result:=SummeKosten;<br />
Memorywuerfel.free;<br />
end;<br />
end;<br />
procedure TAPA_Grid.Showcosts1Click(Sender: TObject);<br />
- 356 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
var zeile,spalte, zahler:longint;<br />
var MatCubes,ReqCubes, MatCubesSorted:TStringList;<br />
var merkeRandom:boolean;<br />
begin<br />
if matcount>0 then begin<br />
//Berechne die Kosten der aktuellen Materialsierung<br />
//auf der Basis der Zufallskosten<br />
//Nur getbuild<br />
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');<br />
{$i-}<br />
reset(fKosten);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('cost database error ');exit;end;<br />
Listbox1.Items.Add('');<br />
Listbox1.Items.Add('Berechne Kosten');<br />
Listbox1.Items.Add('');<br />
ReqCubes:=TStringList.Create;<br />
ReqCubes.Clear;<br />
MatCubes:=TStringList.Create;<br />
MatCubes.Clear;<br />
MatCubesSorted:=TStringList.Create;<br />
MatCubesSorted.Clear;<br />
merkerandom:=Userandomcosts1.Checked;<br />
Userandomcosts1.Checked:=true;<br />
try<br />
//Lege alle nicht redundaten Cubes an, und vergib eine Nummer<br />
for zeile:=0 to anzzeilen-1 do begin<br />
for spalte:=0 to anzspalten-1 do begin<br />
if APA[spalte,zeile].farbe=clYellow then begin<br />
if APA[spalte,zeile].interessant=true then begin<br />
//Speichere Required Cubes<br />
//Merke dir die Required Cubes<br />
ReqCubes.Add(auffuellen(inttostr(spalte),10)+auffuellen(inttostr(zeile),10));<br />
end;<br />
if APA[spalte,zeile].materalisieren=true then begin<br />
//Speichere Mat Cubes<br />
//Merke dir die MatCubes<br />
MatCubes.Add(auffuellen(inttostr(spalte),10)+auffuellen(inttostr(zeile),10));;<br />
end;<br />
end;<br />
end;//end of spalte<br />
end;//end of zeilen<br />
for zahler:=0 to MatCubes.count-1 do MatCubesSorted.Add('free');<br />
for zahler:=0 to MatCubes.Count-1 do begin<br />
MatCubesSorted[APA[strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler],<br />
11,10))].matcount-1]:=<br />
MatCubes[zahler];<br />
end;<br />
showmessage('Costs: '+floattostr(berechneKostenGesamt(MatCubesSorted,ReqCubes,false))+';<br />
Time left: '+<br />
floattostr(timeleft)+'; Space left: '+floattostr(spaceleft));<br />
finally<br />
MatCubes.Free;<br />
ReqCubes.Free;<br />
MatCubesSorted.Free;<br />
Userandomcosts1.Checked:=merkerandom;<br />
- 357 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
CloseFile(fKosten);<br />
end;<br />
end //of matcount<br />
else showmessage('No materialized cubes selected');<br />
end;<br />
function TAPA_Grid.GetRightOrdertom(Listecubes:TStringList):TStringList;<br />
type Knotendeklationszeiger= ^Knotendeklaration;<br />
Knotendeklaration =<br />
record<br />
Knoten:longint;<br />
spalte:longint;<br />
zeile:longint;<br />
MaxAbstand:Extended;<br />
Parent:longint;<br />
end;<br />
var Knoten, Knoten2, Knoten3 , Knotenmerk:Knotendeklationszeiger;<br />
var Innere_Knoten, Randknoten:TList;<br />
var zahler, zahler2, zahler3, zahlermerk:longint;<br />
var costmerk, Kostengewinn:Extended;<br />
var {Parent,} Parentvonderivat:longint;<br />
var {parentcostmerk,} Parentvonderivatcostmerk:Extended;<br />
begin<br />
//Erzeuge alle Randknoten und fülle sie mit den Kosten<br />
Randknoten:= TList.Create;<br />
Innere_Knoten:=TList.Create;<br />
try<br />
for zahler:=0 to Listecubes.Count-1 do begin<br />
//Berechne Maxabstand<br />
//Der Maxabstand ist die Kostenverbesserung der Materialisierung der Derivate von<br />
New(Knoten)<br />
//welche noch nicht materialisiert worden sind.<br />
Kostengewinn:=0;<br />
for zahler2:=0 to Listecubes.count-1 do begin<br />
if<br />
(isderivat(strtoint(copy(Listecubes[zahler],1,10)),strtoint(copy(Listecubes[zahler<br />
],11,10)),<br />
strtoint(copy(Listecubes[zahler2],1,10)),strtoint(copy(Listecubes[zahler2],11,10))<br />
)=true) then begin<br />
if (Userandomcosts1.Checked=true) then begin<br />
Kostengewinn:=Kostengewinn+max(0,<br />
(//Da noch kein Würfel materialisiert wurde werden alle vom BFT<br />
erzeugt<br />
getbuild(-1,-<br />
1,strtoint(copy(Listecubes[zahler2],1,10)),strtoint(copy(Listecubes[zahler2],11,10<br />
))<br />
)<br />
-<br />
getbuild(<br />
strtoint(copy(Listecubes[zahler],1,10)),strtoint(copy(Listecubes[zahler],11,10)),<br />
strtoint(copy(Listecubes[zahler2],1,10)),strtoint(copy(Listecubes[zahler2],11,10))<br />
)<br />
)<br />
);<br />
end else begin<br />
Kostengewinn:=Kostengewinn+max(0,<br />
(//Da noch kein Würfel materialisiert wurde werden alle vom BFT<br />
erzeugt<br />
deltaBftW(strtoint(copy(Listecubes[zahler2],1,10)),strtoint(copy(Listecubes[zahler<br />
2],11,10)),false<br />
)<br />
-<br />
deltaVW(<br />
- 358 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
end;<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
strtoint(copy(Listecubes[zahler],1,10)),strtoint(copy(Listecubes[zahler],11,10)),<br />
strtoint(copy(Listecubes[zahler2],1,10)),strtoint(copy(Listecubes[zahler2],11,10))<br />
,false<br />
)<br />
)<br />
);<br />
end;<br />
end;<br />
New(Knoten);<br />
Knoten^.Knoten:=zahler;<br />
Knoten^.MaxAbstand:=Kostengewinn;<br />
Knoten^.Parent:=-1;<br />
Knoten^.spalte:= strtoint(copy(Listecubes[zahler],1,10));<br />
Knoten^.zeile:=strtoint(copy(Listecubes[zahler],11,10));<br />
Randknoten.Add(Knoten);<br />
end;<br />
//Erzeuge Randknoten Ende<br />
repeat;//So lange durchlaufen, bis die Menge der Randknoten leer<br />
//Finde den Würfel mit dem Minimalen Abstand und setze diesen zu inneren Würfeln zu<br />
zahlermerk:=-1;costmerk:=0;<br />
for zahler:=0 to Randknoten.Count-1 do begin<br />
Knoten:= Randknoten.Items[zahler];<br />
if (Knoten^.MaxAbstand>costmerk) or(zahlermerk=-1) then begin<br />
zahlermerk:=zahler;<br />
costmerk:=Knoten^.MaxAbstand;<br />
end;<br />
end;<br />
//Zusetzen des Würfels zu Inneren Knoten<br />
Knotenmerk:=Randknoten.Items[zahlermerk];<br />
Innere_Knoten.Add(Knotenmerk);<br />
Randknoten.Delete(zahlermerk);<br />
if Randknoten.Count>0 then begin<br />
//Berechne die Kosten neu<br />
//Stelle fest, ob die Randknoten derivate von dem neuen Inneren Knoten sind.<br />
//Wenn ja und die Kosten sind geringer als die vom BFT dann ändere Kosten<br />
//Ist jedoch der neue Cube ein Derivat von dem Randknoten müssen die Kosten neu<br />
berechnet werden<br />
for zahler:=0 to Randknoten.Count-1 do begin<br />
Knoten:=Randknoten.Items[zahler];<br />
if<br />
(isderivat(Knotenmerk^.spalte,Knotenmerk^.zeile,Knoten^.spalte,Knoten^.zeile)=true<br />
)<br />
or<br />
(isderivat(Knoten^.spalte,Knoten^.zeile,Knotenmerk^.spalte,Knotenmerk^.zeile)=true<br />
)<br />
then begin<br />
Kostengewinn:=0;<br />
//Berechne die Derivate<br />
//Durchlaufe alle Randknoten<br />
for zahler2:=0 to Randknoten.Count-1 do begin<br />
Knoten2:=Randknoten.Items[zahler2];<br />
//Stelle fest, ob dieser Randknoten ein Derivat ist<br />
if<br />
(isderivat(Knoten^.spalte,Knoten^.zeile,Knoten2^.spalte,Knoten2.zeile)=true)<br />
and(Knoten^.KnotenKnoten2^.Knoten)<br />
then begin<br />
- 359 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
//Finde das Kostenminimale Parent von Knoten2<br />
Parentvonderivat:=-1;<br />
if (Userandomcosts1.Checked=true) then begin<br />
Parentvonderivatcostmerk:=getbuild(-1,-1,Knoten2.spalte,Knoten2^.zeile);<br />
end else begin<br />
Parentvonderivatcostmerk:=deltaBftW(Knoten2.spalte,Knoten2^.zeile,false);<br />
end;<br />
for zahler3:=0 to Innere_Knoten.count-1 do begin<br />
Knoten3:=Innere_Knoten.Items[zahler3];<br />
if<br />
(isderivat(Knoten3^.spalte,Knoten3^.zeile,Knoten2^.spalte,Knoten2^.zeile)=true)<br />
and(Knoten3^.KnotenKnotenmerk^.Knoten)and(Knoten3^.KnotenKnotenmerk^.Knoten)<br />
then begin<br />
if (Userandomcosts1.Checked=true) then begin<br />
costmerk:=getbuild(Knoten3^.spalte,Knoten3^.zeile,Knoten2^.spalte,Knoten2^.zeile);<br />
end else begin<br />
costmerk:=deltaVW(Knoten3^.spalte,Knoten3^.zeile,Knoten2^.spalte,Knoten2^.zeile,fa<br />
lse);<br />
end;<br />
if (costmerk
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
end;//Ende von Derivat oder Parent<br />
end;<br />
end;//Randknoten.count>0<br />
until Randknoten.Count=0;//So lange durchlaufen, bis die Menge der Randknoten leer ENDE<br />
finally<br />
Listecubes.Clear;<br />
for zahler:=0 to Innere_Knoten.Count-1 do begin<br />
Knoten:=Innere_Knoten.Items[zahler];<br />
Listecubes.Add(auffuellen(inttostr(Knoten^.spalte),10)+auffuellen(inttostr(Knoten^<br />
.zeile),10));<br />
dispose(Knoten);<br />
end;<br />
for zahler:=0 to Randknoten.Count-1 do begin<br />
Knoten:=Innere_Knoten.Items[zahler];<br />
dispose(Knoten);<br />
end;<br />
Innere_Knoten.free;<br />
Randknoten.free;<br />
Result:=Listecubes;<br />
end;<br />
end;<br />
procedure TAPA_Grid.Button4Click(Sender: TObject);<br />
var zeile,spalte,aktzeile,aktspalte,anzderivative:longint;<br />
var x,aktpos,lang,anzcube,reqcube,pos:longint;<br />
var zahler:longint;<br />
var seqcounter:Extended;<br />
var istok:boolean;<br />
var ende:boolean;<br />
var kostenmerk,kostenmerkmin:Extended;<br />
var neustarten:boolean;<br />
var Countliste:array of Longint;<br />
var neuespalte:boolean;<br />
var alwaysspacemaxreached, geladen:boolean;<br />
var st:string;<br />
var GeneriereListe, GeneriereReqListe:TStringList;<br />
begin<br />
assignfile(fMatCubes,'C:\APADIR\DATA\MatCubes.dat');<br />
assignfile(fReqCubes,'C:\APADIR\DATA\ReqCubes.dat');<br />
assignfile(fMerkkosten,'C:\APADIR\DATA\Merkkosten.dat');<br />
assignfile(fCounter,'C:\APADIR\DATA\Counter.dat');<br />
assignfile(fCountermerk,'C:\APADIR\DATA\Countermerk.dat');<br />
assignfile(fCubes,'C:\APADIR\DATA\Cubes.dat');<br />
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');<br />
mustsave:=true;<br />
Removedeterministicsolution1Click(self);<br />
{$i-}<br />
reset(fKosten);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('cost database error ');exit;end;<br />
APA_Grid.Enabled:=false;<br />
GeneriereReqListe:=TStringList.create();<br />
try<br />
{Rechne alle möglichen Kombinationen durch, welche im Bereich des Maximum sind}<br />
// Mache das über eine Temporäre Datei auf der Festplatte<br />
// ist zwar langsamer, aber bei großen Rechnungen hängt sich der Rechner nicht auf.<br />
- 361 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
with APA_Application do begin<br />
APA_Dialog.APA_Text.Caption:='Do you want to restart?';<br />
if permutation=false then begin<br />
if APA_Dialog.showmodal=mryes then<br />
neustarten:=true else neustarten:=false;<br />
end else neustarten:=true;<br />
Permutation:=false;<br />
lang:=0;alwaysspacemaxreached:=false;seqcounter:=0;<br />
APA_Show_Process.APA_Protocoll.Clear;<br />
APA_Show_Process.show;<br />
Application.ProcessMessages;<br />
if neustarten=true then begin;<br />
APA_Show_Process.ausgabe('Clear Tables ...');<br />
{$i-}<br />
rewrite(fCubes);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('Cubes database error ');exit;end;<br />
{$i-}<br />
rewrite(fReqCubes);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('ReqCubes database error ');exit;end;<br />
{$i-}<br />
rewrite(fCounter);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('Counter database error ');exit;end;<br />
{$i-}<br />
rewrite(fMerkkosten);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('ReqCubes database error ');exit;end;<br />
try<br />
seek(fMerkkosten,0);<br />
vMerkkosten.Lfnr:=0;<br />
vMerkkosten.Kosten:=0;<br />
write(fMerkkosten,vMerkkosten);<br />
APA_Show_Process.ausgabe('Search for possible cubes...');<br />
anzcube:=0; reqcube:=0;<br />
//Lege alle nicht redundaten Cubes an, und vergib eine Nummer<br />
for zeile:=0 to anzzeilen-1 do begin<br />
for spalte:=0 to anzspalten-1 do begin<br />
if APA[spalte,zeile].farbe=clYellow then begin<br />
if APA[spalte,zeile].interessant=True then begin<br />
anzcube:=anzcube+1;<br />
seek(fCubes,anzcube-1);<br />
vCubes.Lfnr:=anzcube;<br />
vCubes.Spalte:=spalte;<br />
vCubes.Zeile:=zeile;<br />
vCubes.Required:=1;<br />
write(fCubes,vCubes);<br />
APA_Show_Process.ausgabe('Add Cube:<br />
('+inttostr(spalte)+':'+inttostr(zeile)+')');<br />
end else begin<br />
anzderivative:=0;<br />
for aktzeile:=0 to anzzeilen-1 do begin<br />
for aktspalte:=0 to anzspalten-1 do begin<br />
if (APA[aktspalte,aktzeile].farbe=clYellow)and<br />
(APA[aktspalte,aktzeile].interessant=true) then begin<br />
if isderivat(spalte,zeile,aktspalte,aktzeile) then begin<br />
anzderivative:=anzderivative+1;<br />
end;<br />
end;<br />
end;<br />
- 362 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
end;<br />
if anzderivative>0 then begin<br />
anzcube:=anzcube+1;<br />
seek(fCubes,anzcube-1);<br />
vCubes.Lfnr:=anzcube;<br />
vCubes.Spalte:=spalte;<br />
vCubes.Zeile:=zeile;<br />
vCubes.Required:=1;<br />
write(fCubes,vCubes);<br />
APA_Show_Process.ausgabe('Add Cube:<br />
('+inttostr(spalte)+':'+inttostr(zeile)+')');<br />
end;<br />
end;<br />
if APA[spalte,zeile].interessant=true then begin<br />
//Speichere Required Cubes<br />
//Merke dir die Required Cubes<br />
reqcube:=reqcube+1;<br />
seek(fReqCubes,reqcube-1);<br />
vReqCubes.Lfnr:=reqcube;<br />
vReqCubes.Spalte:=spalte;<br />
vReqCubes.Zeile:=zeile;<br />
write(fReqCubes,vReqCubes);<br />
end;<br />
end;<br />
end;//end of spalte<br />
end;//end of zeilen<br />
finally<br />
CloseFile(fCubes);<br />
CloseFile(fReqCubes);<br />
CloseFile(fCounter);<br />
CloseFile(fMerkkosten);<br />
end;<br />
end;//von neustarten<br />
try<br />
{$i-}<br />
reset(fCubes);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('Cubes database error ');exit;end;<br />
anzcube:=filesize(fCubes);<br />
Setlength(Countliste,anzcube);<br />
MemoryCubes:=nil;<br />
setlength(MemoryCubes,anzcube);<br />
pos:=0;<br />
repeat;<br />
if (filesize(fCubes)>0) then begin<br />
seek(fCubes,pos);<br />
read(fCubes,vCubes);<br />
x:=round(vCubes.lfnr)-1;<br />
Memorycubes[x].nr:=round(vCubes.lfnr);<br />
Memorycubes[x].spalte:=vCubes.Spalte;<br />
Memorycubes[x].zeile:=vCubes.Zeile;<br />
end;<br />
pos:=pos+1;<br />
until pos>=filesize(fCubes);<br />
{$i-}<br />
reset(fReqCubes);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('ReqCubes database error ');exit;end;<br />
try<br />
MemoryreqCubes:=nil;<br />
setlength(MemoryReqCubes,filesize(fReqCubes));<br />
- 363 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
MemoryReqCubescount:=filesize(fReqCubes);<br />
pos:=0;<br />
repeat;<br />
if (filesize(fReqCubes)>0) then begin<br />
seek(fReqCubes,pos);<br />
read(fReqCubes,vReqCubes);<br />
x:=round(vReqCubes.Lfnr)-1;<br />
MemoryReqCubes[x].spalte:=vReqCubes.Spalte;<br />
MemoryReqCubes[x].zeile:=vReqCubes.Zeile;<br />
end;<br />
pos:=pos+1;<br />
until (pos>=filesize(fReqCubes));<br />
for x:=0 to MemoryReqCubescount-1 do begin<br />
GeneriereReqListe.Add(auffuellen(inttostr(MemoryReqCubes[x].spalte),10)+auffuellen<br />
(inttostr(MemoryReqCubes[x].zeile),10));<br />
end;<br />
finally<br />
CloseFile(fReqCubes);<br />
end;<br />
finally<br />
CloseFile(fCubes);<br />
end;<br />
Countliste:=nil;<br />
Setlength(Countliste,anzcube+1);<br />
MerkeListe:=nil;<br />
SetLength(Merkeliste,anzcube);<br />
APA_Show_Process.ausgabe(inttostr(anzcube)+' Cubes found');<br />
if neustarten=true then begin<br />
geladen:=false;<br />
//Zuerst alle 0 setzten<br />
for x:=0 to anzcube do Countliste[x]:=0;<br />
Countliste[0]:=1;<br />
kostenmerkmin:=0;<br />
end// of neustarten<br />
else begin<br />
geladen:=true;<br />
for x:=0 to anzcube-1 do Countliste[x]:=0;<br />
//Laden der Cubes<br />
{$i-}<br />
reset(fCounter);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('ReqCubes database error ');exit;end;<br />
try<br />
lang:=-1;pos:=0;<br />
repeat;<br />
if (filesize(fCounter)>0) then begin<br />
seek(fCounter,pos);<br />
read(fCounter,vCounter);<br />
if vcounter.Lfnr-1 then begin<br />
lang:=lang+1;<br />
x:=round(vCounter.Lfnr);<br />
Countliste[x]:=round(vCounter.nr);<br />
end;<br />
end else begin<br />
//Feststellen von alwaysspacemaxreached<br />
if vcounter.nr=1 then<br />
alwaysspacemaxreached:=true else<br />
alwaysspacemaxreached:=false;<br />
end;<br />
- 364 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
pos:=pos+1;<br />
until pos>=filesize(fCounter);<br />
finally<br />
CloseFile(fCounter);<br />
end;<br />
end;<br />
{$i-}<br />
reset(fMerkkosten);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('Merkkosten database error ');exit;end;<br />
try<br />
seek(fMerkkosten,0);read(fMerkkosten,vMerkkosten);<br />
kostenmerkmin:=vMerkkosten.Kosten;<br />
finally<br />
CloseFile(fMerkkosten);<br />
end;<br />
if anzcube0 then begin<br />
//Kombinatorik<br />
if neustarten=true then begin<br />
Countliste[0]:=1;<br />
lang:=0;<br />
end//neustarten<br />
else APA_Show_Process.ausgabe('*** Restart ***');<br />
ende:=false;<br />
repeat;//until (lang>=anzcube)or(ende=true)<br />
//von links nach rechts nummerieren<br />
if geladen=false then begin<br />
//Beim ersten Start nicht ausführen<br />
//wenn geladen wurde<br />
alwaysspacemaxreached:=true;<br />
end// Ende geladen=false<br />
else geladen:=false;<br />
istok:=true;aktpos:=0;<br />
repeat;//until (neuespalte=true)or(ende=true)<br />
neuespalte:=false;<br />
if istok=true then begin;<br />
//Kontrolliere<br />
//Alle 50000 Einträge lösche die Anzeigeliste um Speicher zu schonen<br />
if APA_Show_Process.APA_Protocoll.Items.Count>50000 then<br />
APA_Show_Process.APA_Protocoll.Items.Clear;<br />
seqcounter:=seqcounter+1;<br />
if alwaysspacemaxreached=true then<br />
APA_Show_Process.ausgabe('>>Add Seq: '+floattostr(seqcounter))<br />
else<br />
APA_Show_Process.ausgabe('>Add Seq: '+floattostr(seqcounter));<br />
//Stelle fest ob spacemax erfüllt.<br />
//Wenn ja ordne die Würfel und berechne Kosten<br />
spaceleftfirstcubes:=strtofloat(APA_Parameter.APA_Thomas_spacemax.text);<br />
spaceleft:=strtofloat(APA_Parameter.APA_Thomas_spacemax.text);<br />
for x:=0 to lang do begin<br />
APA_Show_Process.ausgabe(' '+inttostr(countliste[x]));<br />
- 365 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
spaceleft:=spaceleft-<br />
(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(MemoryCubes[Coun<br />
tliste[x]-1].spalte,MemoryCubes[Countliste[x]-1].zeile));<br />
if x0 then begin<br />
//Rechne den Speicherplatz ohne die letzte Ebene aus.<br />
//Wenn dieser überschritten kann der durchlauf der letzten Ebene gestoppt werden<br />
spaceleftfirstcubes:=spaceleftfirstcubes-<br />
(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(MemoryCubes[Coun<br />
tliste[x]-1].spalte,MemoryCubes[Countliste[x]-1].zeile));<br />
end;<br />
end;//Ende von x<br />
//Wenn überschritten setzt den Zähler der ersten auf max<br />
if spaceleftfirstcubes0 then begin<br />
// Nur wenn die Spacemax Bedingung erfüllt weiterrechnen<br />
alwaysspacemaxreached:=false;<br />
for zahler:=0 to lang do begin<br />
MerkeListe[zahler]:=countliste[zahler];<br />
end;<br />
//Berechne Kosten<br />
GeneriereListe:=TStringList.create();<br />
try<br />
for x:=0 to lang do begin<br />
GeneriereListe.Add(auffuellen(inttostr(MemoryCubes[countliste[x]-<br />
1].spalte),10)+auffuellen(inttostr(MemoryCubes[countliste[x]-1].zeile),10));<br />
end;<br />
for x:=0 to lang do begin<br />
APA_Show_Process.ausgabe('Unsorted: '+inttostr(x)+':<br />
('+inttostr(strtoint(copy(GeneriereListe[x],1,10)))+':'+inttostr(strtoint(copy(Gen<br />
eriereListe[x],11,10)))+')');<br />
end;<br />
APA_Show_Process.ausgabe('Sort Cubes ...');<br />
GeneriereListe:=GetRightOrdertom(GeneriereListe);<br />
for x:=0 to lang do begin<br />
APA_Show_Process.ausgabe('Sorted: '+inttostr(x)+':<br />
('+inttostr(strtoint(copy(GeneriereListe[x],1,10)))+':'+inttostr(strtoint(copy(Gen<br />
eriereListe[x],11,10)))+')');<br />
end;<br />
kostenmerk:=berechneKostenGesamt(GeneriereListe,GeneriereReqListe,true);<br />
finally<br />
GeneriereListe.free;<br />
end;<br />
if kostenmerk>0 then begin<br />
if(kostenmerkmin=0)or(kostenmerkmin>kostenmerk)<br />
then begin;<br />
{$i-}<br />
reset(fMerkkosten);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('Merkkosten database error ');exit;end;<br />
try<br />
- 366 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
APA_Show_Process.ausgabe('*****************');<br />
APA_Show_Process.ausgabe('Trage ein das Minimum '+floattostr(kostenmerk));<br />
vMerkkosten.Kosten:=kostenmerk;<br />
vMerkkosten.Lfnr:=0;<br />
seek(fMerkkosten,0);write(fMerkkosten,vMerkkosten);<br />
kostenmerkmin:=kostenmerk;<br />
seek(fMerkkosten,1);<br />
vMerkkosten.Lfnr:=1;<br />
vMerkkosten.Kosten:=spaceleft;<br />
write(fMerkkosten,vMerkkosten);<br />
seek(fMerkkosten,2);<br />
vMerkkosten.Lfnr:=2;<br />
vMerkkosten.Kosten:=timeleft;<br />
write(fMerkkosten,vMerkkosten);<br />
finally<br />
CloseFile(fMerkkosten);<br />
end;<br />
//Speichere Counttable<br />
assignfile(fCountermerk,'c:\APADIR\DATA\Countermerk.dat');<br />
{$i-}<br />
rewrite(fCountermerk);<br />
{$i+}<br />
if ioresult0 then showmessage('Can not open File Countermerk.dat');<br />
try<br />
for x:=0 to lang do begin<br />
seek(fCountermerk,filesize(fCountermerk));<br />
vCountermerk.Lfnr:=x;<br />
vCountermerk.Nr:=MerkeListe[x];<br />
write(fCountermerk,vCountermerk);<br />
APA_Show_Process.ausgabe('Save Cube Pos:'+floattostr(vCountermerk.Lfnr)+'<br />
Nr:'+floattostr(vCountermerk.Nr));<br />
end;//Ende von x<br />
finally<br />
CloseFile(fCountermerk);<br />
end;<br />
end;//Ende von if(Minkostcubetable['Kosten']=0) ...<br />
end;//Ende von if kostenmerk>0 then begin<br />
end//von if spacemax>0<br />
else<br />
APA_Show_Process.ausgabe('spacemax reached');<br />
end;// von istok<br />
if countliste[aktpos]>=(anzcube-aktpos) then begin<br />
//Setze alle cubes vom aktpos und kleiner auf 1<br />
Countliste[aktpos]:=1;<br />
x:=aktpos;<br />
repeat;<br />
Countliste[x]:=1;<br />
x:=x-1;<br />
until x=-1;<br />
aktpos:=aktpos+1;<br />
if countliste[aktpos]=0 then neuespalte:=true;<br />
Countliste[aktpos]:=countliste[aktpos]+1;<br />
//Finde den nächsten Cube, welcher nicht das Maximum hat<br />
repeat;<br />
if Countliste[aktpos]>(anzcube-aktpos) then begin<br />
aktpos:=aktpos+1;<br />
if (aktpos>anzcube) then begin<br />
aktpos:=anzcube;<br />
- 367 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
ende:=true;<br />
end;<br />
if countliste[aktpos]=0 then neuespalte:=true;<br />
Countliste[aktpos]:=countliste[aktpos]+1;<br />
end;<br />
until (Countliste[aktpos]=0 then begin<br />
Countliste[x]:=Countliste[x+1]+1;<br />
end;<br />
x:=x-1;<br />
until x= ...<br />
else begin;<br />
Countliste[aktpos]:=countliste[aktpos]+1;<br />
aktpos:=0;<br />
end;<br />
Application.processmessages;<br />
while(break=true) do begin;<br />
Application.processmessages;<br />
end;<br />
if APA_Show_Process.Expertmode1.Checked=true then begin<br />
try<br />
repeat;<br />
st:=inputbox('Countnumber','Countnumber:','');<br />
if st'' then begin<br />
x:=strtoint(st);<br />
st:=inputbox('New Countliste','New Countliste:',inttostr(Countliste[x]));<br />
Countliste[x]:=strtoint(st);<br />
end;<br />
until st='';<br />
finally<br />
APA_Show_Process.Expertmode1.Checked:=false;<br />
end;<br />
end;<br />
if APA_Show_Process.GroupBox1.tag=1 then begin<br />
APA_Show_Process.GroupBox1.tag:=0;<br />
neuespalte:=true;//Geheimticker<br />
x:=lang+1;zahler:=0;<br />
repeat;<br />
if x>=0 then begin;<br />
zahler:=zahler+1;<br />
countliste[x]:=zahler;<br />
end;<br />
x:=x-1;<br />
until x=-1;<br />
end;<br />
if APA_Show_Process.GroupBox1.tag=-1 then begin<br />
APA_Show_Process.GroupBox1.tag:=0;<br />
//Geheimticker<br />
countliste[lang]:=0;<br />
lang:=lang-1;<br />
x:=lang;zahler:=0;<br />
repeat;<br />
if x>=0 then begin;<br />
zahler:=zahler+1;<br />
countliste[x]:=zahler;<br />
end;<br />
x:=x-1;<br />
until x=-1;<br />
- 368 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
end;<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
until (neuespalte=true)or(stop=true)or(ende=true);<br />
if (alwaysspacemaxreached=true) and(Alwaysspacemaxbeachten1.Checked=true) then<br />
stop:=true;<br />
//wenn die letzten z.B. 5 Cubes in allen Kombinationen zu wenig Speicherplatz<br />
//hatten, gehen sich 6 Cubes auch nicht aus. Also Ende<br />
lang:=lang+1;<br />
until (ende=true)or(lang>=anzcube)or(stop=true);<br />
//Speichern des aktuellen Cubeliste damit man wieder weiter machen kann.<br />
//Speichern der aktuellen Position<br />
assignfile(fCounter,'c:\APADIR\DATA\Counter.dat');<br />
{$i-}<br />
rewrite(fCounter);<br />
{$i+}<br />
if ioresult0 then showmessage('Can not open File Counter.dat');<br />
try<br />
seek(fCounter,0);<br />
vCounter.Lfnr:=-1;<br />
if vcounter.nr=1 then<br />
if alwaysspacemaxreached=true then vcounter.Nr:=1<br />
else vcounter.Nr:=0;<br />
write(fCounter,vCounter);<br />
for x:=0 to lang do begin<br />
seek(fCounter,x+1);<br />
vCounter.Lfnr:=x;<br />
vCounter.Nr:=Countliste[x];<br />
write(fCounter,vCounter);<br />
end;<br />
finally<br />
CloseFile(fcounter);<br />
end;<br />
end;// Wenn es mindestens einen Cube gibt in der Cubeliste<br />
end;//with Apa_Application<br />
finally<br />
closeFile(fkosten);<br />
GeneriereReqListe.free;<br />
Showmessage('Ready');<br />
APA_Grid.Enabled:=true;<br />
end;<br />
end;<br />
procedure TAPA_Grid.Options1Click(Sender: TObject);<br />
begin<br />
APA_Options.showmodal;<br />
end;<br />
procedure TAPA_Grid.ShowData1Click(Sender: TObject);<br />
var st:string;<br />
begin<br />
st:='Screenbez: '+APA[zellespalte,zellezeile].screenbez;<br />
st:=st+', Counthier:'+inttostr(APA[zellespalte,zellezeile].counthier)+', ';<br />
st:=st+'Countdim: '+inttostr(APA[zellespalte,zellezeile].countdimension)+', ';<br />
st:=st+'Weight: '+floattostr(APA[zellespalte,zellezeile].gewicht)+', ';<br />
st:=st+'Weightlevel: '+inttostr(APA[zellespalte,zellezeile].gewichtlevel)+', ';<br />
st:=st+'Matcount: '+inttostr(APA[zellespalte,zellezeile].matcount)+', ';<br />
showmessage(st);<br />
end;<br />
procedure TAPA_Grid.Button5Click(Sender: TObject);<br />
begin<br />
Panel3.Width:=1;<br />
end;<br />
procedure TAPA_Grid.AlgorithmKombination1Click(Sender: TObject);<br />
- 369 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
begin<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if permutation=false then begin<br />
Button4.click;<br />
end else begin<br />
APA_Dialog.APA_Text.Caption:='Your last deterministic run was a permutation. Do you<br />
want do continue? This will delete your last run!';<br />
end;<br />
end;<br />
if APA_Dialog.showmodal=mryes then begin;<br />
Button4.Click;<br />
end;<br />
procedure TAPA_Grid.AlgorithmKombination2Click(Sender: TObject);<br />
begin<br />
Button4.Click;<br />
end;<br />
procedure TAPA_Grid.GetbuildBFT2Click(Sender: TObject);<br />
begin<br />
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');<br />
{$i-}<br />
reset(fKosten);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('cost database error ');exit;end;<br />
try<br />
//Nur getbuild<br />
showmessage(floattostr(getbuild(-1,-1,zellespalte,zellezeile)));<br />
finally<br />
CloseFile(fKosten);<br />
end;<br />
end;<br />
procedure TAPA_Grid.GetbuildParent2Click(Sender: TObject);<br />
var buildcosts, merkecosts:Extended;<br />
var parentzeile,parentspalte:longint;<br />
var zeile,spalte:longint;<br />
begin<br />
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');<br />
{$i-}<br />
reset(fKosten);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('cost database error ');exit;end;<br />
try<br />
//Nur getbuild<br />
merkecosts:=getbuild(-1,-1,zellespalte,zellezeile);;parentzeile:=-1;parentspalte:=-1;<br />
for zeile:=0 to anzzeilen-1 do begin<br />
for spalte:=0 to anzspalten-1 do begin<br />
if APA[spalte,zeile].materalisieren=true then begin<br />
if isderivat(spalte,zeile,zellespalte,zellezeile)=true then begin<br />
buildcosts:=getbuild(spalte,zeile,zellespalte,zellezeile);<br />
if (buildcosts
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
{$i-}<br />
reset(fKosten);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('cost database error ');exit;end;<br />
try<br />
//Nur getquery<br />
showmessage(floattostr(getquery(-1,-1,zellespalte,zellezeile)));<br />
finally<br />
CloseFile(fKosten);<br />
end;<br />
end;<br />
procedure TAPA_Grid.GetQueryParent2Click(Sender: TObject);<br />
var querycosts, merkecosts:Extended;<br />
var parentzeile,parentspalte:longint;<br />
var zeile,spalte:longint;<br />
begin<br />
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');<br />
{$i-}<br />
reset(fKosten);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('cost database error ');exit;end;<br />
try<br />
//Nur getquery<br />
merkecosts:=getquery(-1,-1,zellespalte,zellezeile);;<br />
parentzeile:=-1;parentspalte:=-1;<br />
for zeile:=0 to anzzeilen-1 do begin<br />
for spalte:=0 to anzspalten-1 do begin<br />
if APA[spalte,zeile].materalisieren=true then begin<br />
if isderivat(spalte,zeile,zellespalte,zellezeile)=true then begin<br />
querycosts:=getquery(spalte,zeile,zellespalte,zellezeile);<br />
if (querycosts
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
procedure TAPA_Grid.Showcosts2Click(Sender: TObject);<br />
begin<br />
Showcosts1Click(self);<br />
end;<br />
procedure TAPA_Grid.ShowAnalyseWindow1Click(Sender: TObject);<br />
begin<br />
Showlistbox1Click(self);<br />
end;<br />
procedure TAPA_Grid.AnalyseAPA1Click(Sender: TObject);<br />
begin<br />
APA_Application.AnalyseAPA1Click(self);<br />
end;<br />
procedure TAPA_Grid.ShowAnalysewindow2Click(Sender: TObject);<br />
begin<br />
APA_Application.AnalyseAPA1Click(self);<br />
end;<br />
procedure TAPA_Grid.Showpossiblecubes1Click(Sender: TObject);<br />
var PossibleCubes:TStringList;<br />
var counter,aktzeile,aktspalte,count_of_derivates:longint;<br />
var zahler,derivspalte,derivzeile:longint;<br />
begin<br />
PossibleCubes:=TStringList.Create();<br />
counter:=0;<br />
for aktzeile:=0 to anzzeilen-1 do begin<br />
for aktspalte:=0 to anzspalten-1 do begin<br />
if (APA[aktspalte,aktzeile].interessant=true)and<br />
(APA[aktspalte,aktzeile].farbe=clYellow) then begin//Auswählen des Würfels<br />
PossibleCubes.Add(auffuellen(inttostr(aktspalte),10)+auffuellen(inttostr(aktzeile)<br />
,10));<br />
counter:=counter+1;<br />
end;//of Auswählen des Würfels<br />
end;//of aktspalte<br />
end;//of aktzeile<br />
{1.b Setze Derivate zu}<br />
if tomohnederivate1.Checked=false then begin<br />
for aktzeile:=0 to anzzeilen-1 do begin<br />
for aktspalte:=0 to anzspalten-1 do begin<br />
if<br />
(APA[aktspalte,aktzeile].farbe=clYellow)and(APA[aktspalte,aktzeile].interessant=fa<br />
lse) then begin<br />
count_of_derivates:=0;<br />
for derivspalte:=0 to anzspalten-1 do begin;<br />
for derivzeile:=0 to anzzeilen-1 do begin;<br />
if (APA[derivspalte,derivzeile].interessant=true)and<br />
(APA[derivspalte,derivzeile].farbe=clYellow) then begin<br />
if isderivat(aktspalte,aktzeile,derivspalte,derivzeile) then begin<br />
//Jetzt kontrollieren wir, ob dieser Würfel auch noch ein Derivat eines<br />
anderen Würfels<br />
count_of_derivates:=count_of_derivates+1;<br />
end;//Ende von derivat<br />
end;//Ende von interessant<br />
end;//of derivzeile<br />
end;//of derivsspalte<br />
if count_of_derivates>=1 then begin<br />
PossibleCubes.Add(auffuellen(inttostr(aktspalte),10)+auffuellen(inttostr(aktzeile)<br />
,10));<br />
counter:=counter+1;<br />
end;<br />
end;//von Yellow<br />
- 372 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
end;//aktspalte<br />
end;//aktzeile<br />
end;<br />
for zahler:=0 to PossibleCubes.count-1 do begin<br />
APA[strtoint(copy(PossibleCubes[zahler],1,10)),strtoint(copy(PossibleCubes[zahler],11,10<br />
))].flag:=1;<br />
end;<br />
APAGrid.Repaint;<br />
showmessage('Found '+inttostr(counter)+' possible cubes. ');<br />
Showpossiblecubes2.Visible:=false;<br />
Removepossiblecubes2.Visible:=true;<br />
end;<br />
procedure TAPA_Grid.Removepossiblecubes1Click(Sender: TObject);<br />
var aktzeile,aktspalte:longint;<br />
begin<br />
for aktzeile:=0 to anzzeilen-1 do begin<br />
for aktspalte:=0 to anzspalten-1 do begin<br />
APA[aktspalte,aktzeile].flag:=0;<br />
end;<br />
end;<br />
APAGrid.Repaint;<br />
Showpossiblecubes2.Visible:=true;<br />
Removepossiblecubes2.Visible:=false;<br />
end;<br />
procedure TAPA_Grid.Showpossiblecubes2Click(Sender: TObject);<br />
begin<br />
Showpossiblecubes1Click(self);<br />
end;<br />
procedure TAPA_Grid.Removepossiblecubes2Click(Sender: TObject);<br />
begin<br />
Removepossiblecubes1Click(self);<br />
end;<br />
procedure TAPA_Grid.Getmaterialisationspaceofcube1Click(Sender: TObject);<br />
begin<br />
showmessage('Space required:<br />
'+floattostr((strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(zel<br />
lespalte,zellezeile))));<br />
end;<br />
procedure TAPA_Grid.ShowButtons1Click(Sender: TObject);<br />
begin<br />
Button1.Visible:=true;<br />
Button2.Visible:=true;<br />
Button3.Visible:=true;<br />
Button4.Visible:=true;<br />
end;<br />
procedure TAPA_Grid.GetbuildBFT1Click(Sender: TObject);<br />
begin<br />
//Nur delta<br />
showmessage('The Materialisation costs are<br />
'+floattostr(deltaBFTW(zellespalte,zellezeile,false)));<br />
end;<br />
procedure TAPA_Grid.GetqueryfromBFT1Click(Sender: TObject);<br />
begin<br />
//Nur delta<br />
showmessage('The Query costs are '+floattostr(deltaBFTW(zellespalte,zellezeile,true)));<br />
end;<br />
- 373 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
procedure TAPA_Grid.Getbuildfromparent1Click(Sender: TObject);<br />
var buildcosts, merkecosts:Extended;<br />
var parentzeile,parentspalte:longint;<br />
var zeile,spalte:longint;<br />
begin<br />
//Nur delta<br />
merkecosts:=deltaBFTW(zellespalte,zellezeile,false);parentzeile:=-1;parentspalte:=-1;<br />
for zeile:=0 to anzzeilen-1 do begin<br />
for spalte:=0 to anzspalten-1 do begin<br />
if APA[spalte,zeile].materalisieren=true then begin<br />
if isderivat(spalte,zeile,zellespalte,zellezeile)=true then begin<br />
buildcosts:=deltaVW(spalte,zeile,zellespalte,zellezeile,false);<br />
if (buildcosts
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
MatCubes:=TStringList.Create;<br />
MatCubes.Clear;<br />
MatCubesSorted:=TStringList.Create;<br />
MatCubesSorted.Clear;<br />
merkerandom:=Userandomcosts1.Checked;<br />
Userandomcosts1.Checked:=false;<br />
try<br />
//Lege alle nicht redundaten Cubes an, und vergib eine Nummer<br />
for zeile:=0 to anzzeilen-1 do begin<br />
for spalte:=0 to anzspalten-1 do begin<br />
if APA[spalte,zeile].farbe=clYellow then begin<br />
if APA[spalte,zeile].interessant=true then begin<br />
//Speichere Required Cubes<br />
//Merke dir die Required Cubes<br />
ReqCubes.Add(auffuellen(inttostr(spalte),10)+auffuellen(inttostr(zeile),10));<br />
end;<br />
if APA[spalte,zeile].materalisieren=true then begin<br />
//Speichere Mat Cubes<br />
//Merke dir die MatCubes<br />
MatCubes.Add(auffuellen(inttostr(spalte),10)+auffuellen(inttostr(zeile),10));;<br />
end;<br />
end;<br />
end;//end of spalte<br />
end;//end of zeilen<br />
for zahler:=0 to MatCubes.count-1 do MatCubesSorted.Add('free');<br />
for zahler:=0 to MatCubes.Count-1 do begin<br />
MatCubesSorted[APA[strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler],<br />
11,10))].matcount-1]:=<br />
MatCubes[zahler];<br />
end;<br />
showmessage('Costs: '+floattostr(berechneKostenGesamt(MatCubesSorted,ReqCubes,false))+';<br />
Time left: '+<br />
floattostr(timeleft)+'; Space left: '+floattostr(spaceleft));<br />
finally<br />
MatCubes.Free;<br />
ReqCubes.Free;<br />
MatCubesSorted.Free;<br />
Userandomcosts1.Checked:=merkerandom;<br />
end;<br />
end //of matcount<br />
else showmessage('No materialized cubes selected');<br />
end;<br />
procedure TAPA_Grid.Restrictedcosts1Click(Sender: TObject);<br />
begin<br />
APA_Application.Restrictedcosts1.Checked:=APA_Grid.Restrictedcosts1.Checked;<br />
end;<br />
procedure TAPA_Grid.Showdeterministicsolution2Click(Sender: TObject);<br />
begin<br />
Showdeterministicsolution1Click(self);<br />
end;<br />
procedure TAPA_Grid.Showdeterministicsolution1Click(Sender: TObject);<br />
var countcube,pos:longint;<br />
var SolutionList:TStringList;<br />
begin<br />
- 375 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
assignfile(fCountermerk,'c:\APADIR\DATA\Countermerk.dat');<br />
{$i-}<br />
reset(fCountermerk);<br />
{$i+}<br />
if ioresult0 then showmessage('Can not open File Countermerk.dat');<br />
try<br />
if filesize(fCountermerk)>0 then begin<br />
SolutionList:=TStringList.Create();<br />
try<br />
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');<br />
{$i-}<br />
reset(fKosten);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('cost database error ');exit;end;<br />
assignfile(fCubes,'C:\APADIR\DATA\Cubes.dat');<br />
{$i-}<br />
reset(fCubes);<br />
{$i+}<br />
if ioresult0 then showmessage('Can not open File Cubes.dat');<br />
pos:=0;<br />
repeat;<br />
if filesize(fcountermerk)>0 then begin<br />
seek(fCountermerk,pos);<br />
read(fCountermerk,vCountermerk);<br />
seek(fCubes,round(vCountermerk.nr)-1);<br />
read(fCubes,vCubes);<br />
SolutionList.Add(auffuellen(inttostr(vCubes.Spalte),10)+auffuellen(inttostr(vCubes<br />
.Zeile),10));<br />
end;<br />
pos:=pos+1;<br />
until pos=filesize(fCountermerk);<br />
SolutionList:=GetRightOrdertom(SolutionList);<br />
for countcube:=0 to SolutionList.Count-1 do begin<br />
end;<br />
APA[strtoint(copy(SolutionList[countcube],1,10)),strtoint(copy(SolutionList[countc<br />
ube],11,10))].flag:=(2+((countcube+1)/10000))<br />
Showdeterministicsolution2.Visible:=false;<br />
Removedeterministicsolution2.Visible:=true;<br />
APAGrid.Repaint;<br />
finally<br />
CloseFile(fKosten);<br />
CloseFile(fCubes);<br />
SolutionList.Free;<br />
end;<br />
end else showmessage('No solution found');<br />
finally<br />
CloseFile(fCountermerk);<br />
end;<br />
end;<br />
procedure TAPA_Grid.Removedeterministicsolution1Click(Sender: TObject);<br />
var zeile,spalte:longint;<br />
begin<br />
for spalte:=0 to anzspalten-1 do begin<br />
for zeile:=0 to anzzeilen-1 do begin<br />
if (APA[spalte,zeile].flag>=2)and(APA[spalte,zeile].flag
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
end;<br />
end;<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Showdeterministicsolution2.Visible:=true;<br />
Removedeterministicsolution2.Visible:=false;<br />
APAGrid.Repaint;<br />
end;<br />
procedure TAPA_Grid.Removedeterministicsolution2Click(Sender: TObject);<br />
begin<br />
Removedeterministicsolution1Click(self);<br />
end;<br />
procedure TAPA_Grid.GenerateCREATESQLStatementsBFTanddimensiontables3Click(<br />
Sender: TObject);<br />
var counter, counter2:longint;<br />
var Fieldnamemerk ,Fieldtypemerk:string;<br />
begin<br />
//Generiere BFT Table und Dimension Tables<br />
APA_Sql.Sqltext.lines.Clear;<br />
//1. Generiere Dimension Tables<br />
for counter:=0 to anzd-1 do begin//Counter für Dimensionen<br />
APA_Sql.Sqltext.lines.add('if exists (select * from dbo.sysobjects where id =<br />
object_id(N''[dbo].[FK_BFT_'+dimbez[counter]+'_table]'')');<br />
APA_Sql.Sqltext.lines.add(' and OBJECTPROPERTY(id, N''IsForeignKey'') = 1)');<br />
APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].[BFT] DROP CONSTRAINT<br />
FK_BFT_'+dimbez[counter]+'_table');<br />
APA_Sql.Sqltext.lines.add('GO');<br />
APA_Sql.Sqltext.lines.add('');<br />
APA_Sql.Sqltext.lines.add('if exists (select * from dbo.sysobjects where id =<br />
object_id(N''[dbo].['+dimbez[counter]+'_table]'') and OBJECTPROPERTY(id,<br />
N''IsUserTable'') = 1)');<br />
APA_Sql.Sqltext.lines.add('drop table [dbo].['+dimbez[counter]+'_table]');<br />
APA_Sql.Sqltext.lines.add('GO');<br />
APA_Sql.Sqltext.lines.add('');<br />
APA_Sql.Sqltext.lines.add('CREATE TABLE [dbo].['+dimbez[counter]+'_table] (');<br />
APA_Sql.Sqltext.lines.add(' ['+dimbez[counter]+'_id] [varchar] (50) COLLATE<br />
Latin1_General_CI_AS NOT NULL ,');<br />
for counter2:=0 to anzh[counter]-1 do begin//Counter für Hierarchiestufen<br />
APA_Sql.Sqltext.lines.add(' ['+dk[counter,counter2]+'] [varchar] (12) COLLATE<br />
Latin1_General_CI_AS NOT NULL ,');<br />
APA_Sql.Sqltext.lines.add(' ['+dk[counter,counter2]+'_desc] [varchar] (40) COLLATE<br />
Latin1_General_CI_AS NOT NULL ,');<br />
end;//Counter für Hierarchiestufen<br />
APA_Sql.Sqltext.lines.add(' [level] [bigint] NOT NULL');<br />
APA_Sql.Sqltext.lines.add(') ON [PRIMARY]');<br />
APA_Sql.Sqltext.lines.add('GO');<br />
APA_Sql.Sqltext.lines.add('');<br />
APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].['+dimbez[counter]+'_table] WITH NOCHECK<br />
ADD');<br />
APA_Sql.Sqltext.lines.add(' CONSTRAINT [PK_'+dimbez[counter]+'_table] PRIMARY KEY<br />
CLUSTERED');<br />
APA_Sql.Sqltext.lines.add(' (');<br />
APA_Sql.Sqltext.lines.add(' ['+dimbez[counter]+'_id]');<br />
APA_Sql.Sqltext.lines.add(' ) ON [PRIMARY]');<br />
APA_Sql.Sqltext.lines.add('GO');<br />
APA_Sql.Sqltext.lines.add('');<br />
end;//Counter für Dimensionen Ende<br />
//2. Generiere BFT Table<br />
APA_Sql.Sqltext.lines.add('if exists (select * from dbo.sysobjects where id =<br />
object_id(N''[dbo].[BFT]'')');<br />
APA_Sql.Sqltext.lines.add('and OBJECTPROPERTY(id, N''IsUserTable'') = 1)');<br />
APA_Sql.Sqltext.lines.add('drop table [dbo].[BFT]');<br />
APA_Sql.Sqltext.lines.add('GO');<br />
APA_Sql.Sqltext.lines.add('');<br />
APA_Sql.Sqltext.lines.add('CREATE TABLE [dbo].[BFT] (');<br />
for counter:=0 to anzd-1 do begin<br />
- 377 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
APA_Sql.Sqltext.lines.add(' ['+dimbez[counter]+'_id] [varchar] (50) COLLATE<br />
Latin1_General_CI_AS NOT NULL ,');<br />
end;<br />
for counter:=0 to APA_Input_Screen.Keybox.Items.Count-1 do begin<br />
Fieldnamemerk:=<br />
copy(APA_Input_Screen.Keybox.items[counter],1,pos('//',APA_Input_Screen.Keybox.ite<br />
ms[counter])-1);<br />
Fieldtypemerk:=<br />
APA_Insert_Key.APA_Field_type.Items[APA_Insert_Key.APA_Field_type.Items.IndexOf(co<br />
py(APA_Input_Screen.Keybox.items[counter],pos('//',APA_Input_Screen.Keybox.items[c<br />
ounter])+6,<br />
length(APA_Input_Screen.Keybox.items[counter])-<br />
(pos('//',APA_Input_Screen.Keybox.items[counter])+6)))];<br />
APA_Sql.Sqltext.lines.add(' ['+Fieldnamemerk+'] ['+Fieldtypemerk+'] NOT NULL ,');<br />
end;<br />
//Beistrich entfernen<br />
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=<br />
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,<br />
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);<br />
APA_Sql.Sqltext.lines.add(') ON [PRIMARY]');<br />
APA_Sql.Sqltext.lines.add('GO');<br />
APA_Sql.Sqltext.lines.add('');<br />
APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].[BFT] WITH NOCHECK ADD');<br />
APA_Sql.Sqltext.lines.add(' CONSTRAINT [PK_BFT] PRIMARY KEY CLUSTERED');<br />
APA_Sql.Sqltext.lines.add(' (');<br />
for counter:=0 to anzd-1 do begin<br />
APA_Sql.Sqltext.lines.add(' ['+dimbez[counter]+'_id],');<br />
end;<br />
//Beistrich entfernen<br />
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=<br />
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,<br />
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);<br />
APA_Sql.Sqltext.lines.add(' ) ON [PRIMARY]');<br />
APA_Sql.Sqltext.lines.add('GO');<br />
APA_Sql.Sqltext.lines.add('');<br />
//3. Zusetzen der FK Schlüssel<br />
for counter:=0 to anzd-1 do begin<br />
APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].[BFT] ADD');<br />
APA_Sql.Sqltext.lines.add(' CONSTRAINT [FK_BFT_'+dimbez[counter]+'_table] FOREIGN<br />
KEY');<br />
APA_Sql.Sqltext.lines.add(' (');<br />
APA_Sql.Sqltext.lines.add(' ['+dimbez[counter]+'_id]');<br />
APA_Sql.Sqltext.lines.add(' ) REFERENCES [dbo].['+dimbez[counter]+'_table] (');<br />
APA_Sql.Sqltext.lines.add(' ['+dimbez[counter]+'_id]');<br />
APA_Sql.Sqltext.lines.add(' ) ON UPDATE CASCADE ');<br />
APA_Sql.Sqltext.lines.add('');<br />
APA_Sql.Sqltext.lines.add('GO');<br />
APA_Sql.Sqltext.lines.add('');<br />
end; //of counter<br />
APA_Sql.Show;<br />
end;<br />
procedure TAPA_Grid.GenerateCREATESQLStatementsformaterializedcubes2Click(<br />
Sender: TObject);<br />
var spalte,zeile,zahler:longint;<br />
var tablename:string;<br />
var counter:longint;<br />
var Fieldnamemerk ,Fieldtypemerk:string;<br />
var foundcube:boolean;<br />
begin<br />
- 378 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
{1. Für alle materialisierten Würfel}<br />
APA_Sql.Sqltext.lines.Clear;<br />
foundcube:=false;<br />
for spalte:=0 to anzspalten-1 do begin<br />
for zeile:=0 to anzzeilen-1 do begin<br />
if APA[spalte,zeile].materalisieren=true then begin<br />
tablename:='';foundcube:=true;<br />
for zahler:=0 to anzd-1 do begin<br />
tablename:=tablename+dk[zahler,APA[spalte,zeile].hierstufe[zahler]];<br />
end;<br />
APA_Sql.Sqltext.lines.add('');<br />
APA_Sql.Sqltext.lines.add('if exists (select * from dbo.sysobjects where ');<br />
APA_Sql.Sqltext.lines.add('id = object_id(N''[dbo].[FT '+tablename+']'') and<br />
OBJECTPROPERTY(id, N''IsUserTable'') = 1)');<br />
APA_Sql.Sqltext.lines.add('drop table [dbo].[FT '+tablename+']');<br />
APA_Sql.Sqltext.lines.add('GO');<br />
APA_Sql.Sqltext.lines.add('');<br />
APA_Sql.Sqltext.lines.add('CREATE TABLE [dbo].[FT '+tablename+'] ( ');<br />
for zahler:=0 to anzd-1 do begin<br />
if (anzh[zahler]-1APA[spalte,zeile].hierstufe[zahler]) then<br />
APA_Sql.Sqltext.lines.add(' ['+dk[zahler,APA[spalte,zeile].hierstufe[zahler]]+']<br />
[varchar] (12) COLLATE Latin1_General_CI_AS NOT NULL ,');<br />
end;<br />
for counter:=0 to APA_Input_Screen.Keybox.Items.Count-1 do begin<br />
Fieldnamemerk:=<br />
copy(APA_Input_Screen.Keybox.items[counter],1,pos('//',APA_Input_Screen.Keybox.ite<br />
ms[counter])-1);<br />
Fieldtypemerk:=<br />
APA_Insert_Key.APA_Field_type.Items[APA_Insert_Key.APA_Field_type.Items.IndexOf(co<br />
py(APA_Input_Screen.Keybox.items[counter],pos('//',APA_Input_Screen.Keybox.items[c<br />
ounter])+6,<br />
length(APA_Input_Screen.Keybox.items[counter])-<br />
(pos('//',APA_Input_Screen.Keybox.items[counter])+6)))];<br />
APA_Sql.Sqltext.lines.add(' ['+Fieldnamemerk+'] ['+Fieldtypemerk+'] NOT NULL ,');<br />
end;<br />
//Beistrich entfernen<br />
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=<br />
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,<br />
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);<br />
APA_Sql.Sqltext.lines.add(') ON [PRIMARY]');<br />
APA_Sql.Sqltext.lines.add('GO');<br />
APA_Sql.Sqltext.lines.add('');<br />
APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].[FT '+tablename+'] WITH NOCHECK ADD');<br />
APA_Sql.Sqltext.lines.add(' CONSTRAINT [PK_FT '+tablename+'] PRIMARY KEY CLUSTERED');<br />
APA_Sql.Sqltext.lines.add(' ( ');<br />
for zahler:=0 to anzd-1 do begin<br />
if (anzh[zahler]-1APA[spalte,zeile].hierstufe[zahler]) then<br />
APA_Sql.Sqltext.lines.add(' ['+dk[zahler,APA[spalte,zeile].hierstufe[zahler]]+'] ,');<br />
end;<br />
//Beistrich entfernen<br />
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=<br />
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,<br />
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);<br />
APA_Sql.Sqltext.lines.add(' ) ON [PRIMARY]');<br />
APA_Sql.Sqltext.lines.add('GO');<br />
APA_Sql.Sqltext.lines.add('');<br />
end; //End Materialisieren<br />
end;// End Zeile<br />
end;//End Spalte<br />
if foundcube=true then<br />
APA_Sql.Show<br />
- 379 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
else<br />
showmessage('No materialized cube found!');<br />
end;<br />
procedure TAPA_Grid.GenerateCREATESQLStatementsBFTanddimensiontables2Click(<br />
Sender: TObject);<br />
var counter, counter2:longint;<br />
var Fieldnamemerk ,Fieldtypemerk:string;<br />
begin<br />
//Generiere BFT Table und Dimension Tables<br />
APA_Sql.Sqltext.lines.Clear;<br />
//1. Generiere Dimension Tables<br />
for counter:=0 to anzd-1 do begin//Counter für Dimensionen<br />
APA_Sql.Sqltext.lines.add('if exists (select * from dbo.sysobjects where id =<br />
object_id(N''[dbo].[FK_BFT_'+dimbez[counter]+'_table]'')');<br />
APA_Sql.Sqltext.lines.add(' and OBJECTPROPERTY(id, N''IsForeignKey'') = 1)');<br />
APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].[BFT] DROP CONSTRAINT<br />
FK_BFT_'+dimbez[counter]+'_table');<br />
APA_Sql.Sqltext.lines.add('GO');<br />
APA_Sql.Sqltext.lines.add('');<br />
APA_Sql.Sqltext.lines.add('if exists (select * from dbo.sysobjects where id =<br />
object_id(N''[dbo].['+dimbez[counter]+'_table]'') and OBJECTPROPERTY(id,<br />
N''IsUserTable'') = 1)');<br />
APA_Sql.Sqltext.lines.add('drop table [dbo].['+dimbez[counter]+'_table]');<br />
APA_Sql.Sqltext.lines.add('GO');<br />
APA_Sql.Sqltext.lines.add('');<br />
APA_Sql.Sqltext.lines.add('CREATE TABLE [dbo].['+dimbez[counter]+'_table] (');<br />
//Primärschlüssel<br />
APA_Sql.Sqltext.lines.add(' ['+dimbez[counter]+'_id] [varchar] (50) COLLATE<br />
Latin1_General_CI_AS NOT NULL ,');<br />
for counter2:=0 to anzh[counter]-1 do begin//Counter für Hierarchiestufen<br />
APA_Sql.Sqltext.lines.add(' ['+dk[counter,counter2]+'] [varchar] (12) COLLATE<br />
Latin1_General_CI_AS NOT NULL ,');<br />
APA_Sql.Sqltext.lines.add(' ['+dk[counter,counter2]+'_desc] [varchar] (40) COLLATE<br />
Latin1_General_CI_AS NOT NULL ,');<br />
end;//Counter für Hierarchiestufen<br />
APA_Sql.Sqltext.lines.add(') ON [PRIMARY]');<br />
APA_Sql.Sqltext.lines.add('GO');<br />
APA_Sql.Sqltext.lines.add('');<br />
APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].['+dimbez[counter]+'_table] WITH NOCHECK<br />
ADD');<br />
APA_Sql.Sqltext.lines.add(' CONSTRAINT [PK_'+dimbez[counter]+'_table] PRIMARY KEY<br />
CLUSTERED');<br />
APA_Sql.Sqltext.lines.add(' (');<br />
APA_Sql.Sqltext.lines.add(' ['+dimbez[counter]+'_id]');<br />
APA_Sql.Sqltext.lines.add(' ) ON [PRIMARY]');<br />
APA_Sql.Sqltext.lines.add('GO');<br />
APA_Sql.Sqltext.lines.add('');<br />
for counter2:=0 to anzh[counter]-1 do begin<br />
APA_Sql.Sqltext.lines.add(' CREATE INDEX [IX_'+dk[counter,counter2]+'] ON<br />
[dbo].['+dimbez[counter]+'_table](['+dk[counter,counter2]+']) ON [PRIMARY]');<br />
APA_Sql.Sqltext.lines.add('GO');<br />
APA_Sql.Sqltext.lines.add('');<br />
end;<br />
end;//Counter für Dimensionen Ende<br />
//2. Generiere BFT Table<br />
APA_Sql.Sqltext.lines.add('if exists (select * from dbo.sysobjects where id =<br />
object_id(N''[dbo].[BFT]'')');<br />
APA_Sql.Sqltext.lines.add('and OBJECTPROPERTY(id, N''IsUserTable'') = 1)');<br />
APA_Sql.Sqltext.lines.add('drop table [dbo].[BFT]');<br />
- 380 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
APA_Sql.Sqltext.lines.add('GO');<br />
APA_Sql.Sqltext.lines.add('');<br />
APA_Sql.Sqltext.lines.add('CREATE TABLE [dbo].[BFT] (');<br />
for counter:=0 to anzd-1 do begin<br />
APA_Sql.Sqltext.lines.add(' ['+dimbez[counter]+'_id] [varchar] (50) COLLATE<br />
Latin1_General_CI_AS NOT NULL ,');<br />
end;<br />
for counter:=0 to APA_Input_Screen.Keybox.Items.Count-1 do begin<br />
Fieldnamemerk:=<br />
copy(APA_Input_Screen.Keybox.items[counter],1,pos('//',APA_Input_Screen.Keybox.ite<br />
ms[counter])-1);<br />
Fieldtypemerk:=<br />
APA_Insert_Key.APA_Field_type.Items[APA_Insert_Key.APA_Field_type.Items.IndexOf(co<br />
py(APA_Input_Screen.Keybox.items[counter],pos('//',APA_Input_Screen.Keybox.items[c<br />
ounter])+6,<br />
length(APA_Input_Screen.Keybox.items[counter])-<br />
(pos('//',APA_Input_Screen.Keybox.items[counter])+6)))];<br />
APA_Sql.Sqltext.lines.add(' ['+Fieldnamemerk+'] ['+Fieldtypemerk+'] NOT NULL ,');<br />
end;<br />
//Beistrich entfernen<br />
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=<br />
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,<br />
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);<br />
APA_Sql.Sqltext.lines.add(') ON [PRIMARY]');<br />
APA_Sql.Sqltext.lines.add('GO');<br />
APA_Sql.Sqltext.lines.add('');<br />
APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].[BFT] WITH NOCHECK ADD');<br />
APA_Sql.Sqltext.lines.add(' CONSTRAINT [PK_BFT] PRIMARY KEY CLUSTERED');<br />
APA_Sql.Sqltext.lines.add(' (');<br />
for counter:=0 to anzd-1 do begin<br />
APA_Sql.Sqltext.lines.add(' ['+dimbez[counter]+'_id],');<br />
end;<br />
//Beistrich entfernen<br />
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=<br />
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,<br />
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);<br />
APA_Sql.Sqltext.lines.add(' ) ON [PRIMARY]');<br />
APA_Sql.Sqltext.lines.add('GO');<br />
APA_Sql.Sqltext.lines.add('');<br />
//3. Zusetzen der FK Schlüssel<br />
for counter:=0 to anzd-1 do begin<br />
APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].[BFT] ADD');<br />
APA_Sql.Sqltext.lines.add(' CONSTRAINT [FK_BFT_'+dimbez[counter]+'_table] FOREIGN<br />
KEY');<br />
APA_Sql.Sqltext.lines.add(' (');<br />
APA_Sql.Sqltext.lines.add(' ['+dimbez[counter]+'_id]');<br />
APA_Sql.Sqltext.lines.add(' ) REFERENCES [dbo].['+dimbez[counter]+'_table] (');<br />
APA_Sql.Sqltext.lines.add(' ['+dimbez[counter]+'_id]');<br />
APA_Sql.Sqltext.lines.add(' ) ON UPDATE CASCADE ');<br />
APA_Sql.Sqltext.lines.add('');<br />
APA_Sql.Sqltext.lines.add('GO');<br />
APA_Sql.Sqltext.lines.add('');<br />
end; //of counter<br />
APA_Sql.Show;<br />
end;<br />
procedure TAPA_Grid.GenerateCREATESQLStatementsBFTanddimensiontables1Click(<br />
Sender: TObject);<br />
begin<br />
GenerateCREATESQLStatementsBFTanddimensiontables2Click(self);<br />
- 381 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
end;<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
procedure TAPA_Grid.GenerateCREATESQLStatementsformaterializedcubes1Click(<br />
Sender: TObject);<br />
begin<br />
GenerateCREATESQLStatementsformaterializedcubes2Click(self);<br />
end;<br />
procedure TAPA_Grid.APAGridMouseWheelUp(Sender: TObject;<br />
Shift: TShiftState; MousePos: TPoint; var Handled: Boolean);<br />
begin<br />
zellespalte:=-1;<br />
zellezeile:=-1;<br />
end;<br />
procedure TAPA_Grid.HelpforAPAGridScreen1Click(Sender: TObject);<br />
begin<br />
APA_Help.show;<br />
APA_Help.APABrowser.Navigate('C:\APADIR\Help\APA_Grid.htm');<br />
end;<br />
procedure TAPA_Grid.HelpforAPAProgram1Click(Sender: TObject);<br />
begin<br />
APA_Help.show;<br />
APA_Help.APABrowser.Navigate('C:\APADIR\Help\index.htm');<br />
end;<br />
procedure TAPA_Grid.factconstellationschema1Click(Sender: TObject);<br />
var aktspalte,aktzeile,parentzeile,parentspalte, counter:longint;<br />
var merkcosts, bestmerkcosts:Extended;<br />
var sumdimension:array of longint;<br />
var tablename:string;<br />
var nix, gleich:boolean;<br />
begin<br />
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');<br />
{$i-}<br />
reset(fKosten);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('cost database error ');exit;end;<br />
try<br />
{1. Finden den Cube oder den BFT aus welchem abgefragt wird}<br />
parentzeile:=-1;parentspalte:=-1;// Kann immer aus dem BFT abgeleitet werden<br />
if (Userandomcosts1.Checked=true) then begin<br />
bestmerkcosts:=getquery(-1,-1,zellespalte,zellezeile);<br />
end else begin<br />
bestmerkcosts:=deltaBftW(zellespalte,zellezeile,true);<br />
end;<br />
for aktzeile:=0 to anzzeilen-1 do begin<br />
for aktspalte:=0 to anzspalten-1 do begin<br />
if APA[aktspalte,aktzeile].materalisieren=true then begin<br />
if isderivat(aktspalte,aktzeile,zellespalte,zellezeile)=true then begin<br />
if (Userandomcosts1.Checked=true) then begin<br />
merkcosts:=getquery(aktspalte,aktzeile,zellespalte,zellezeile);<br />
end else begin<br />
merkcosts:=deltaVW(aktspalte,aktzeile,zellespalte,zellezeile,true);<br />
end;<br />
if merkcosts
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
{2.1. Finde die Dimensionen welche aggregiert werden müssen}<br />
sumdimension:=nil;<br />
setlength(sumdimension,anzd);<br />
for counter:=0 to anzd-1 do sumdimension[counter]:=-1;<br />
for counter:=0 to anzd-1 do begin<br />
if (APA[zellespalte,zellezeile].hierstufe[counter]anzh[counter]-1) then begin<br />
sumdimension[counter]:=APA[zellespalte,zellezeile].hierstufe[counter];<br />
end;<br />
end;<br />
APA_Sql.Sqltext.lines.Clear;<br />
if parentspalte=-1 then begin<br />
APA_Sql.Sqltext.lines.add('SELECT ');<br />
for counter:=0 to anzd-1 do begin<br />
if sumdimension[counter]-1 then begin<br />
//Feld aus dem Dimension table<br />
APA_Sql.Sqltext.lines.add('<br />
dbo.['+dimbez[counter]+'_table].['+dk[counter,APA[zellespalte,zellezeile].hierstuf<br />
e[counter]]+'],');<br />
end;<br />
end;<br />
for counter:=0 to APA_Input_Screen.Keybox.Items.Count-1 do begin<br />
APA_Sql.Sqltext.lines.add(copy(APA_Input_Screen.Keybox.items[counter],pos('//',APA<br />
_Input_Screen.Keybox.items[counter])+2,3)+'(['+<br />
copy(APA_Input_Screen.Keybox.items[counter],1,pos('//',APA_Input_Screen.Keybox.ite<br />
ms[counter])-1)+'])'+<br />
' AS<br />
['+copy(APA_Input_Screen.Keybox.items[counter],1,pos('//',APA_Input_Screen.Keybox.<br />
items[counter])-1)+'],');<br />
end;<br />
//Beistrich entfernen<br />
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=<br />
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,<br />
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);<br />
APA_Sql.Sqltext.lines.add('FROM dbo.BFT');<br />
for counter:=0 to anzd-1 do begin<br />
if sumdimension[counter]-1 then begin<br />
//Feld aus dem Dimension table<br />
APA_Sql.Sqltext.lines.add(' INNER JOIN dbo.['+dimbez[counter]+'_table] ON<br />
dbo.BFT.['+dimbez[counter]+'_id]=');<br />
APA_Sql.Sqltext.lines.add('<br />
dbo.['+dimbez[counter]+'_table].['+dimbez[counter]+'_id]');<br />
end;<br />
end;<br />
APA_Sql.Sqltext.lines.add('GROUP BY ');<br />
for counter:=0 to anzd-1 do begin<br />
if sumdimension[counter]-1 then begin<br />
//Feld aus dem Dimension table<br />
APA_Sql.Sqltext.lines.add('<br />
dbo.['+dimbez[counter]+'_table].['+dk[counter,APA[zellespalte,zellezeile].hierstuf<br />
e[counter]]+'],');<br />
end;<br />
end;<br />
//Beistrich entfernen<br />
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=<br />
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,<br />
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);<br />
end else begin<br />
//Abfrage aus dem aggregierten Cube<br />
- 383 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
tablename:='';nix:=true;<br />
for counter:=0 to anzd-1 do begin<br />
tablename:=tablename+dk[counter,APA[parentspalte,parentzeile].hierstufe[counter]];<br />
end;<br />
gleich:=true;<br />
for counter:=0 to anzd-1 do begin<br />
if (APA[zellespalte,zellezeile].hierstufe[counter]><br />
APA[parentspalte,parentzeile].hierstufe[counter])<br />
and(APA[zellespalte,zellezeile].hierstufe[counter]anzh[counter]-1) then begin<br />
sumdimension[counter]:=APA[zellespalte,zellezeile].hierstufe[counter];<br />
end;<br />
if<br />
(APA[zellespalte,zellezeile].hierstufe[counter]APA[parentspalte,parentzeile].hie<br />
rstufe[counter])<br />
then gleich:=false;<br />
end;<br />
APA_Sql.Sqltext.lines.add('SELECT ');<br />
if gleich=false then begin<br />
for counter:=0 to anzd-1 do begin<br />
if sumdimension[counter]-1 then begin<br />
//Feld aus dem Dimension table<br />
if (anzh[counter]-1APA[zellespalte,zellezeile].hierstufe[counter]) then<br />
begin;<br />
APA_Sql.Sqltext.lines.add('<br />
dbo.['+dimbez[counter]+'_table].['+dk[counter,APA[zellespalte,zellezeile].hierstuf<br />
e[counter]]+'],');<br />
nix:=false;<br />
end;<br />
end else begin<br />
//Feld aus dem Abfrage Table<br />
if (anzh[counter]-1APA[zellespalte,zellezeile].hierstufe[counter]) then<br />
begin;<br />
APA_Sql.Sqltext.lines.add('<br />
dbo.['+tablename+'].['+dk[counter,APA[zellespalte,zellezeile].hierstufe[counter]]+<br />
'],');<br />
nix:=false;<br />
end;<br />
end;<br />
end;<br />
for counter:=0 to APA_Input_Screen.Keybox.Items.Count-1 do begin<br />
APA_Sql.Sqltext.lines.add(copy(APA_Input_Screen.Keybox.items[counter],pos('//',APA<br />
_Input_Screen.Keybox.items[counter])+2,3)+'(['+<br />
copy(APA_Input_Screen.Keybox.items[counter],1,pos('//',APA_Input_Screen.Keybox.ite<br />
ms[counter])-1)+'])'+<br />
' AS<br />
['+copy(APA_Input_Screen.Keybox.items[counter],1,pos('//',APA_Input_Screen.Keybox.<br />
items[counter])-1)+'],');<br />
end;<br />
//Beistrich entfernen<br />
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=<br />
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,<br />
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);<br />
end // von gleich<br />
else<br />
APA_Sql.Sqltext.lines.add('*');<br />
APA_Sql.Sqltext.lines.add('FROM dbo.['+tablename+']');<br />
if gleich=false then begin<br />
for counter:=0 to anzd-1 do begin<br />
if sumdimension[counter]-1 then begin<br />
//Feld aus dem Dimension table<br />
if (anzh[counter]-1APA[zellespalte,zellezeile].hierstufe[counter]) then<br />
begin<br />
APA_Sql.Sqltext.lines.add(' INNER JOIN dbo.['+dimbez[counter]+'_table] ON<br />
dbo.['+tablename+'].['+dk[counter,APA[parentspalte,parentzeile].hierstufe[counter]<br />
]+']=');<br />
- 384 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
end;<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
APA_Sql.Sqltext.lines.add('<br />
dbo.['+dimbez[counter]+'_table].['+dk[counter,APA[parentspalte,parentzeile].hierst<br />
ufe[counter]]+']');<br />
end;<br />
end;<br />
end;<br />
if nix=false then<br />
APA_Sql.Sqltext.lines.add('GROUP BY ');<br />
for counter:=0 to anzd-1 do begin<br />
if sumdimension[counter]-1 then begin<br />
//Feld aus dem Dimension table<br />
if (anzh[counter]-1APA[zellespalte,zellezeile].hierstufe[counter]) then<br />
APA_Sql.Sqltext.lines.add('<br />
dbo.['+dimbez[counter]+'_table].['+dk[counter,APA[zellespalte,zellezeile].hierstuf<br />
e[counter]]+'],');<br />
end else begin<br />
//Feld aus dem BFT Table<br />
if (anzh[counter]-1APA[zellespalte,zellezeile].hierstufe[counter]) then<br />
APA_Sql.Sqltext.lines.add('<br />
dbo.['+tablename+'].['+dk[counter,APA[zellespalte,zellezeile].hierstufe[counter]]+<br />
'],');<br />
end;<br />
end;<br />
//Beistrich entfernen<br />
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=<br />
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,<br />
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);<br />
end; // von gleich<br />
finally<br />
CloseFile(fKosten);<br />
end;<br />
APA_Sql.Show;<br />
end;<br />
procedure TAPA_Grid.starschema1Click(Sender: TObject);<br />
var aktspalte,aktzeile,parentzeile,parentspalte, counter:longint;<br />
var merkcosts, bestmerkcosts:Extended;<br />
var sumdimension:array of longint;<br />
begin<br />
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');<br />
{$i-}<br />
reset(fKosten);<br />
{$i+}<br />
if ioresult0 then begin; showmessage('cost database error ');exit;end;<br />
try<br />
{1. Finden den Cube oder den BFT aus welchem abgefragt wird}<br />
parentzeile:=-1;parentspalte:=-1;// Kann immer aus dem BFT abgeleitet werden<br />
if (Userandomcosts1.Checked=true) then begin<br />
bestmerkcosts:=getquery(-1,-1,zellespalte,zellezeile);<br />
end else begin<br />
bestmerkcosts:=deltaBftW(zellespalte,zellezeile,true);<br />
end;<br />
for aktzeile:=0 to anzzeilen-1 do begin<br />
for aktspalte:=0 to anzspalten-1 do begin<br />
if APA[aktspalte,aktzeile].materalisieren=true then begin<br />
if isderivat(aktspalte,aktzeile,zellespalte,zellezeile)=true then begin<br />
if (Userandomcosts1.Checked=true) then begin<br />
merkcosts:=getquery(aktspalte,aktzeile,zellespalte,zellezeile);<br />
end else begin<br />
merkcosts:=deltaVW(aktspalte,aktzeile,zellespalte,zellezeile,true);<br />
end;<br />
- 385 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if merkcosts
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if sumdimension[counter]-1 then begin<br />
//Feld aus dem Dimension table<br />
APA_Sql.Sqltext.lines.add('<br />
dbo.['+dimbez[counter]+'_table].['+dk[counter,APA[zellespalte,zellezeile].hierstuf<br />
e[counter]]+'],');<br />
end;<br />
end;<br />
//Beistrich entfernen<br />
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=<br />
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,<br />
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);<br />
end else begin<br />
//Abfrage aus dem aggregierten Cube<br />
APA_Sql.Sqltext.lines.add('SELECT ');<br />
for counter:=0 to anzd-1 do begin<br />
if sumdimension[counter]-1 then begin<br />
//Feld aus dem Dimension table<br />
APA_Sql.Sqltext.lines.add('<br />
dbo.['+dimbez[counter]+'_table].['+dk[counter,APA[zellespalte,zellezeile].hierstuf<br />
e[counter]]+'],');<br />
end;<br />
end;<br />
for counter:=0 to APA_Input_Screen.Keybox.Items.Count-1 do begin<br />
APA_Sql.Sqltext.lines.add(copy(APA_Input_Screen.Keybox.items[counter],pos('//',APA<br />
_Input_Screen.Keybox.items[counter])+2,3)+'(['+<br />
copy(APA_Input_Screen.Keybox.items[counter],1,pos('//',APA_Input_Screen.Keybox.ite<br />
ms[counter])-1)+'])'+<br />
' AS<br />
['+copy(APA_Input_Screen.Keybox.items[counter],1,pos('//',APA_Input_Screen.Keybox.<br />
items[counter])-1)+'],');<br />
end;<br />
//Beistrich entfernen<br />
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=<br />
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,<br />
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);<br />
APA_Sql.Sqltext.lines.add('FROM dbo.BFT');<br />
for counter:=0 to anzd-1 do begin<br />
//Feld aus dem Dimension table<br />
APA_Sql.Sqltext.lines.add(' INNER JOIN dbo.['+dimbez[counter]+'_table] ON<br />
dbo.BFT.['+dimbez[counter]+'_id]=');<br />
APA_Sql.Sqltext.lines.add('<br />
dbo.['+dimbez[counter]+'_table].['+dimbez[counter]+'_id]');<br />
end;<br />
APA_Sql.Sqltext.lines.add('WHERE ');<br />
for counter:=0 to anzd-1 do begin<br />
//Feld aus dem Dimension table<br />
if counter0 then APA_Sql.Sqltext.lines.add(' AND ');<br />
APA_Sql.Sqltext.lines.add(' (dbo.['+dimbez[counter]+'_table].[level]='<br />
+inttostr(APA[parentspalte,parentzeile].hierstufe[counter])+')');<br />
end;<br />
APA_Sql.Sqltext.lines.add('GROUP BY ');<br />
for counter:=0 to anzd-1 do begin<br />
if sumdimension[counter]-1 then begin<br />
//Feld aus dem Dimension table<br />
APA_Sql.Sqltext.lines.add('<br />
dbo.['+dimbez[counter]+'_table].['+dk[counter,APA[zellespalte,zellezeile].hierstuf<br />
e[counter]]+'],');<br />
end;<br />
end;<br />
- 387 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
end;<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
//Beistrich entfernen<br />
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=<br />
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,<br />
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);<br />
finally<br />
CloseFile(fKosten);<br />
end;<br />
APA_Sql.Show;<br />
end;<br />
end.<br />
12.1.10 UNIT APA_HELPUNIT.DFM<br />
object APA_Help: TAPA_Help<br />
Left = 220<br />
Top = 114<br />
Width = 696<br />
Height = 480<br />
Caption = 'APA Help'<br />
Color = clBtnFace<br />
Font.Charset = DEFAULT_CHARSET<br />
Font.Color = clWindowText<br />
Font.Height = -11<br />
Font.Name = 'MS Sans Serif'<br />
Font.Style = []<br />
OldCreateOrder = False<br />
Position = poScreenCenter<br />
WindowState = wsMaximized<br />
PixelsPerInch = 96<br />
TextHeight = 13<br />
object APABrowser: TWebBrowser<br />
Left = 0<br />
Top = 41<br />
Width = 688<br />
Height = 364<br />
Align = alClient<br />
TabOrder = 0<br />
ControlData = {<br />
4C0000001B4700009F2500000000000000000000000000000000000000000000<br />
000000004C000000000000000000000001000000E0D057007335CF11AE690800<br />
2B2E126208000000000000004C0000000114020000000000C000000000000046<br />
8000000000000000000000000000000000000000000000000000000000000000<br />
00000000000000000100000000000000000000000000000000000000}<br />
end<br />
object Panel2: TPanel<br />
Left = 0<br />
Top = 405<br />
Width = 688<br />
Height = 41<br />
Align = alBottom<br />
TabOrder = 1<br />
object Button1: TButton<br />
Left = 16<br />
Top = 8<br />
Width = 75<br />
Height = 25<br />
Cancel = True<br />
Caption = 'Close'<br />
TabOrder = 0<br />
OnClick = Button1Click<br />
end<br />
end<br />
object Panel1: TPanel<br />
Left = 0<br />
Top = 0<br />
- 388 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Width = 688<br />
Height = 41<br />
Align = alTop<br />
TabOrder = 2<br />
object Button2: TButton<br />
Left = 16<br />
Top = 8<br />
Width = 75<br />
Height = 25<br />
Caption = 'Back'<br />
TabOrder = 0<br />
OnClick = Button2Click<br />
end<br />
object Button3: TButton<br />
Left = 104<br />
Top = 8<br />
Width = 75<br />
Height = 25<br />
Caption = 'Forward'<br />
TabOrder = 1<br />
OnClick = Button3Click<br />
end<br />
end<br />
end<br />
12.1.11 UNIT APA_HELPUNIT.PAS<br />
unit APA_Helpunit;<br />
interface<br />
uses<br />
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,<br />
Dialogs, StdCtrls, ExtCtrls, OleCtrls, SHDocVw;<br />
type<br />
TAPA_Help = class(TForm)<br />
APABrowser: TWebBrowser;<br />
Panel2: TPanel;<br />
Button1: TButton;<br />
Panel1: TPanel;<br />
Button2: TButton;<br />
Button3: TButton;<br />
procedure Button1Click(Sender: TObject);<br />
procedure Button2Click(Sender: TObject);<br />
procedure Button3Click(Sender: TObject);<br />
private<br />
{ Private-Deklarationen }<br />
public<br />
{ Public-Deklarationen }<br />
end;<br />
var<br />
APA_Help: TAPA_Help;<br />
implementation<br />
{$R *.dfm}<br />
procedure TAPA_Help.Button1Click(Sender: TObject);<br />
begin<br />
Close;<br />
end;<br />
procedure TAPA_Help.Button2Click(Sender: TObject);<br />
begin<br />
try<br />
APABrowser.GoBack;<br />
except<br />
showmessage('Not Possible');<br />
end;<br />
- 389 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
end;<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
procedure TAPA_Help.Button3Click(Sender: TObject);<br />
begin<br />
try<br />
APABrowser.GoForward;<br />
except<br />
showmessage('Not Possible');<br />
end;<br />
end;<br />
end.<br />
12.1.12 UNIT APA_INPUT_DIMENSIONUNIT.DFM<br />
object APA_Insert_Dimension: TAPA_Insert_Dimension<br />
Left = 297<br />
Top = 234<br />
ActiveControl = Dimension<br />
BorderStyle = bsDialog<br />
Caption = 'APA_Insert_Dimension'<br />
ClientHeight = 125<br />
ClientWidth = 320<br />
Color = clBtnFace<br />
Font.Charset = DEFAULT_CHARSET<br />
Font.Color = clWindowText<br />
Font.Height = -11<br />
Font.Name = 'MS Sans Serif'<br />
Font.Style = []<br />
OldCreateOrder = False<br />
Position = poScreenCenter<br />
OnShow = FormShow<br />
PixelsPerInch = 96<br />
TextHeight = 13<br />
object Bevel1: TBevel<br />
Left = 11<br />
Top = 10<br />
Width = 297<br />
Height = 65<br />
Shape = bsFrame<br />
end<br />
object Label1: TLabel<br />
Left = 27<br />
Top = 18<br />
Width = 103<br />
Height = 13<br />
Caption = 'Dimension description'<br />
end<br />
object OKBtn: TButton<br />
Left = 82<br />
Top = 90<br />
Width = 75<br />
Height = 25<br />
Caption = 'OK'<br />
Default = True<br />
Enabled = False<br />
ModalResult = 1<br />
TabOrder = 0<br />
OnClick = OKBtnClick<br />
end<br />
object CancelBtn: TButton<br />
Left = 162<br />
Top = 90<br />
Width = 75<br />
Height = 25<br />
Cancel = True<br />
Caption = 'Cancel'<br />
ModalResult = 2<br />
TabOrder = 1<br />
OnClick = CancelBtnClick<br />
end<br />
object Dimension: TEdit<br />
- 390 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Left = 27<br />
Top = 34<br />
Width = 257<br />
Height = 21<br />
MaxLength = 40<br />
TabOrder = 2<br />
OnChange = DimensionChange<br />
end<br />
end<br />
12.1.13 UNIT APA_INPUT_DIMENSIONUNIT.PAS<br />
unit APA_Input_Dimensionunit;<br />
interface<br />
uses<br />
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,<br />
Dialogs, StdCtrls, ExtCtrls;<br />
type<br />
TAPA_Insert_Dimension = class(TForm)<br />
Bevel1: TBevel;<br />
OKBtn: TButton;<br />
CancelBtn: TButton;<br />
Label1: TLabel;<br />
Dimension: TEdit;<br />
procedure DimensionChange(Sender: TObject);<br />
procedure CancelBtnClick(Sender: TObject);<br />
procedure FormShow(Sender: TObject);<br />
procedure OKBtnClick(Sender: TObject);<br />
private<br />
{ Private-Deklarationen }<br />
public<br />
{ Public-Deklarationen }<br />
end;<br />
var<br />
APA_Insert_Dimension: TAPA_Insert_Dimension;<br />
implementation<br />
{$R *.dfm}<br />
procedure TAPA_Insert_Dimension.DimensionChange(Sender: TObject);<br />
begin<br />
OKBtn.Enabled:=true;<br />
end;<br />
procedure TAPA_Insert_Dimension.CancelBtnClick(Sender: TObject);<br />
begin<br />
Close;<br />
end;<br />
procedure TAPA_Insert_Dimension.FormShow(Sender: TObject);<br />
begin<br />
Dimension.SetFocus;<br />
end;<br />
procedure TAPA_Insert_Dimension.OKBtnClick(Sender: TObject);<br />
var st:string;<br />
begin<br />
if (pos('//',Dimension.Text)0) then begin;<br />
showmessage('Sting "//" is not allowed in dimension');<br />
st:=Dimension.Text;<br />
delete(st,pos('//',st),2);<br />
Dimension.Text:=st;<br />
end;<br />
end;<br />
end.<br />
- 391 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
12.1.14 UNIT APA_INPUT_HIERARCHYUNIT.DFM<br />
object APA_Insert_Hierarchy: TAPA_Insert_Hierarchy<br />
Left = 220<br />
Top = 114<br />
ActiveControl = short_hierarchy<br />
BorderStyle = bsDialog<br />
Caption = 'APA_Insert_Hierarchy'<br />
ClientHeight = 209<br />
ClientWidth = 325<br />
Color = clBtnFace<br />
Font.Charset = DEFAULT_CHARSET<br />
Font.Color = clWindowText<br />
Font.Height = -11<br />
Font.Name = 'MS Sans Serif'<br />
Font.Style = []<br />
OldCreateOrder = False<br />
Position = poScreenCenter<br />
OnShow = FormShow<br />
PixelsPerInch = 96<br />
TextHeight = 13<br />
object Bevel1: TBevel<br />
Left = 14<br />
Top = 14<br />
Width = 297<br />
Height = 150<br />
Shape = bsFrame<br />
end<br />
object Label1: TLabel<br />
Left = 30<br />
Top = 22<br />
Width = 125<br />
Height = 13<br />
Caption = 'Hierarchy short description'<br />
end<br />
object Label2: TLabel<br />
Left = 30<br />
Top = 70<br />
Width = 122<br />
Height = 13<br />
Caption = 'Hierarchy long description'<br />
end<br />
object Label3: TLabel<br />
Left = 30<br />
Top = 114<br />
Width = 99<br />
Height = 13<br />
Caption = 'Count of datarecords'<br />
end<br />
object OKBtn: TButton<br />
Left = 85<br />
Top = 170<br />
Width = 75<br />
Height = 25<br />
Caption = 'OK'<br />
Default = True<br />
Enabled = False<br />
ModalResult = 1<br />
TabOrder = 3<br />
OnClick = OKBtnClick<br />
end<br />
object CancelBtn: TButton<br />
Left = 165<br />
Top = 170<br />
Width = 75<br />
Height = 25<br />
Cancel = True<br />
Caption = 'Cancel'<br />
ModalResult = 2<br />
TabOrder = 4<br />
OnClick = CancelBtnClick<br />
end<br />
object short_hierarchy: TEdit<br />
- 392 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Left = 30<br />
Top = 38<br />
Width = 131<br />
Height = 21<br />
MaxLength = 10<br />
TabOrder = 0<br />
OnChange = short_hierarchyChange<br />
end<br />
object long_hierarchy: TEdit<br />
Left = 30<br />
Top = 86<br />
Width = 257<br />
Height = 21<br />
MaxLength = 40<br />
TabOrder = 1<br />
OnChange = long_hierarchyChange<br />
end<br />
object datarecords: TMaskEdit<br />
Left = 30<br />
Top = 128<br />
Width = 257<br />
Height = 21<br />
EditMask = '0##############;0; '<br />
MaxLength = 15<br />
TabOrder = 2<br />
Text = '1'<br />
end<br />
end<br />
12.1.15 UNIT APA_INPUT_HIERARCHYUNIT.PAS<br />
unit APA_Input_Hierarchyunit;<br />
interface<br />
uses<br />
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,<br />
Dialogs, StdCtrls, ExtCtrls, Mask;<br />
type<br />
TAPA_Insert_Hierarchy = class(TForm)<br />
Bevel1: TBevel;<br />
OKBtn: TButton;<br />
CancelBtn: TButton;<br />
Label1: TLabel;<br />
short_hierarchy: TEdit;<br />
Label2: TLabel;<br />
long_hierarchy: TEdit;<br />
Label3: TLabel;<br />
datarecords: TMaskEdit;<br />
procedure short_hierarchyChange(Sender: TObject);<br />
procedure long_hierarchyChange(Sender: TObject);<br />
procedure OKBtnClick(Sender: TObject);<br />
procedure CancelBtnClick(Sender: TObject);<br />
procedure FormShow(Sender: TObject);<br />
private<br />
{ Private-Deklarationen }<br />
public<br />
{ Public-Deklarationen }<br />
end;<br />
var<br />
APA_Insert_Hierarchy: TAPA_Insert_Hierarchy;<br />
implementation<br />
{$R *.dfm}<br />
procedure TAPA_Insert_Hierarchy.short_hierarchyChange(Sender: TObject);<br />
begin<br />
if (length(short_hierarchy.Text)0)and<br />
(length(long_hierarchy.Text)0) then OKBtn.Enabled:=true;<br />
- 393 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
end;<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
procedure TAPA_Insert_Hierarchy.long_hierarchyChange(Sender: TObject);<br />
begin<br />
if (length(short_hierarchy.Text)0)and<br />
(length(long_hierarchy.Text)0) then OKBtn.Enabled:=true;<br />
end;<br />
procedure TAPA_Insert_Hierarchy.OKBtnClick(Sender: TObject);<br />
var st:string;<br />
begin<br />
{Überprüfe, ob // nicht im shortstring vorkommt}<br />
if (pos('//',short_hierarchy.Text)0) then begin;<br />
showmessage('Sting "//" is not allowed in short description');<br />
st:=short_hierarchy.Text;<br />
delete(st,pos('//',st),2);<br />
short_hierarchy.Text:=st;<br />
end;<br />
if (pos('//',long_hierarchy.Text)0) then begin;<br />
showmessage('Sting "//" is not allowed in long description');<br />
st:=long_hierarchy.Text;<br />
delete(st,pos('//',st),2);<br />
long_hierarchy.Text:=st;<br />
end;<br />
if (pos('//',datarecords.Text)0) then begin;<br />
showmessage('Sting "//" is not allowed in datarecords');<br />
st:=datarecords.Text;<br />
delete(st,pos('//',st),2);<br />
datarecords.Text:=st;<br />
end;<br />
if (pos('::',short_hierarchy.Text)0) then begin;<br />
showmessage('Sting "::" is not allowed in short description');<br />
st:=short_hierarchy.Text;<br />
delete(st,pos('//',st),2);<br />
short_hierarchy.Text:=st;<br />
end;<br />
if (pos('::',long_hierarchy.Text)0) then begin;<br />
showmessage('Sting "::" is not allowed in long description');<br />
st:=long_hierarchy.Text;<br />
delete(st,pos('::',st),2);<br />
long_hierarchy.Text:=st;<br />
end;<br />
if (pos('::',datarecords.Text)0) then begin;<br />
showmessage('Sting "::" is not allowed in datarecords');<br />
st:=datarecords.Text;<br />
delete(st,pos('::',st),2);<br />
datarecords.Text:=st;<br />
end;<br />
try<br />
if strtoint(datarecords.Text)
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
end;<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
procedure TAPA_Insert_Hierarchy.FormShow(Sender: TObject);<br />
begin<br />
short_hierarchy.SetFocus;<br />
end;<br />
end.<br />
12.1.16 UNIT APA_INPUT_REQBLOCKUNIT.DFM<br />
object APA_Insert_Hierarchy: TAPA_Insert_Hierarchy<br />
Left = 220<br />
Top = 114<br />
ActiveControl = short_hierarchy<br />
BorderStyle = bsDialog<br />
Caption = 'APA_Insert_Hierarchy'<br />
ClientHeight = 209<br />
ClientWidth = 325<br />
Color = clBtnFace<br />
Font.Charset = DEFAULT_CHARSET<br />
Font.Color = clWindowText<br />
Font.Height = -11<br />
Font.Name = 'MS Sans Serif'<br />
Font.Style = []<br />
OldCreateOrder = False<br />
Position = poScreenCenter<br />
OnShow = FormShow<br />
PixelsPerInch = 96<br />
TextHeight = 13<br />
object Bevel1: TBevel<br />
Left = 14<br />
Top = 14<br />
Width = 297<br />
Height = 150<br />
Shape = bsFrame<br />
end<br />
object Label1: TLabel<br />
Left = 30<br />
Top = 22<br />
Width = 125<br />
Height = 13<br />
Caption = 'Hierarchy short description'<br />
end<br />
object Label2: TLabel<br />
Left = 30<br />
Top = 70<br />
Width = 122<br />
Height = 13<br />
Caption = 'Hierarchy long description'<br />
end<br />
object Label3: TLabel<br />
Left = 30<br />
Top = 114<br />
Width = 99<br />
Height = 13<br />
Caption = 'Count of datarecords'<br />
end<br />
object OKBtn: TButton<br />
Left = 85<br />
Top = 170<br />
Width = 75<br />
Height = 25<br />
Caption = 'OK'<br />
Default = True<br />
Enabled = False<br />
ModalResult = 1<br />
TabOrder = 3<br />
OnClick = OKBtnClick<br />
end<br />
object CancelBtn: TButton<br />
Left = 165<br />
- 395 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Top = 170<br />
Width = 75<br />
Height = 25<br />
Cancel = True<br />
Caption = 'Cancel'<br />
ModalResult = 2<br />
TabOrder = 4<br />
OnClick = CancelBtnClick<br />
end<br />
object short_hierarchy: TEdit<br />
Left = 30<br />
Top = 38<br />
Width = 131<br />
Height = 21<br />
MaxLength = 10<br />
TabOrder = 0<br />
OnChange = short_hierarchyChange<br />
end<br />
object long_hierarchy: TEdit<br />
Left = 30<br />
Top = 86<br />
Width = 257<br />
Height = 21<br />
MaxLength = 40<br />
TabOrder = 1<br />
OnChange = long_hierarchyChange<br />
end<br />
object datarecords: TMaskEdit<br />
Left = 30<br />
Top = 128<br />
Width = 257<br />
Height = 21<br />
EditMask = '0##############;0; '<br />
MaxLength = 15<br />
TabOrder = 2<br />
Text = '1'<br />
end<br />
end<br />
12.1.17 UNIT APA_INPUT_REQBLOCKUNIT.PAS<br />
unit APA_Input_Reqblockunit;<br />
interface<br />
uses<br />
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,<br />
Dialogs, StdCtrls, ExtCtrls;<br />
type<br />
TAPA_Insert_Reqblock = class(TForm)<br />
Bevel1: TBevel;<br />
OKBtn: TButton;<br />
CancelBtn: TButton;<br />
Label1: TLabel;<br />
Reqname: TEdit;<br />
Add_max_hier: TCheckBox;<br />
Importance_of_requirement: TListBox;<br />
Label2: TLabel;<br />
procedure FormShow(Sender: TObject);<br />
procedure Importance_of_requirementClick(Sender: TObject);<br />
procedure ReqnameChange(Sender: TObject);<br />
private<br />
{ Private-Deklarationen }<br />
public<br />
{ Public-Deklarationen }<br />
end;<br />
var<br />
APA_Insert_Reqblock: TAPA_Insert_Reqblock;<br />
implementation<br />
- 396 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
uses APA_Parameterunit;<br />
{$R *.dfm}<br />
procedure TAPA_Insert_Reqblock.FormShow(Sender: TObject);<br />
var merkindex,g:longint;//Zähler<br />
begin<br />
merkindex:=Importance_of_requirement.ItemIndex;<br />
Reqname.SetFocus;<br />
Importance_of_requirement.Items.Clear;<br />
//Festlegen der Required Spalten<br />
for g:=0 to APA_Parameter.APA_Degrees.Count-1 do begin<br />
Importance_of_requirement.Items.Add(APA_Parameter.APA_Degrees.Items[g]);<br />
end;<br />
Importance_of_requirement.ItemIndex:=merkindex;<br />
if Importance_of_requirement.ItemIndex=-1 then Importance_of_requirement.ItemIndex:=0;<br />
end;<br />
procedure TAPA_Insert_Reqblock.Importance_of_requirementClick(<br />
Sender: TObject);<br />
begin<br />
OKBtn.Enabled:=true;<br />
end;<br />
procedure TAPA_Insert_Reqblock.ReqnameChange(Sender: TObject);<br />
begin<br />
OKBtn.Enabled:=true;<br />
end;<br />
end.<br />
12.1.18 UNIT APA_INPUT_SCREENUNIT.DFM<br />
object APA_Input_Screen: TAPA_Input_Screen<br />
Left = 206<br />
Top = 119<br />
Width = 604<br />
Height = 568<br />
Caption = 'APA Input Screen'<br />
Color = clBtnFace<br />
Font.Charset = DEFAULT_CHARSET<br />
Font.Color = clWindowText<br />
Font.Height = -11<br />
Font.Name = 'MS Sans Serif'<br />
Font.Style = []<br />
OldCreateOrder = False<br />
Position = poScreenCenter<br />
OnCloseQuery = FormCloseQuery<br />
OnShow = FormShow<br />
PixelsPerInch = 96<br />
TextHeight = 13<br />
object Panel1: TPanel<br />
Left = 0<br />
Top = 493<br />
Width = 596<br />
Height = 41<br />
Align = alBottom<br />
TabOrder = 0<br />
object Saveandexit_button: TButton<br />
Left = 16<br />
Top = 8<br />
Width = 75<br />
Height = 25<br />
Caption = 'Save && Exit'<br />
Enabled = False<br />
ModalResult = 1<br />
TabOrder = 0<br />
OnClick = Saveandexit_buttonClick<br />
end<br />
- 397 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
object Abortandexit_button: TButton<br />
Left = 104<br />
Top = 8<br />
Width = 75<br />
Height = 25<br />
Caption = 'Abort && Exit'<br />
ModalResult = 2<br />
TabOrder = 1<br />
OnClick = Abortandexit_buttonClick<br />
end<br />
end<br />
object Panel2: TPanel<br />
Left = 0<br />
Top = 0<br />
Width = 596<br />
Height = 41<br />
Align = alTop<br />
TabOrder = 1<br />
object Button_insert_dimension: TButton<br />
Left = 8<br />
Top = 8<br />
Width = 90<br />
Height = 25<br />
Caption = 'Insert dimension'<br />
TabOrder = 0<br />
OnClick = Button_insert_dimensionClick<br />
end<br />
object Button_delete: TButton<br />
Left = 220<br />
Top = 8<br />
Width = 90<br />
Height = 25<br />
Caption = 'Delete'<br />
TabOrder = 2<br />
OnClick = Button_deleteClick<br />
end<br />
object Button_Edit: TButton<br />
Left = 327<br />
Top = 8<br />
Width = 90<br />
Height = 25<br />
Caption = 'Edit'<br />
TabOrder = 3<br />
OnClick = Button_EditClick<br />
end<br />
object Button_insert_hierarchy: TButton<br />
Left = 114<br />
Top = 8<br />
Width = 90<br />
Height = 25<br />
Caption = 'Insert hierarchy'<br />
TabOrder = 1<br />
OnClick = Button_insert_hierarchyClick<br />
end<br />
end<br />
object Panel3: TPanel<br />
Left = 0<br />
Top = 41<br />
Width = 65<br />
Height = 340<br />
Align = alLeft<br />
TabOrder = 2<br />
object APA_dimbox: TGroupBox<br />
Left = 1<br />
Top = 1<br />
Width = 63<br />
Height = 72<br />
Align = alTop<br />
Caption = 'Dimension'<br />
Enabled = False<br />
TabOrder = 0<br />
object Button_dim_up: TButton<br />
Left = 8<br />
Top = 16<br />
- 398 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Width = 50<br />
Height = 25<br />
Caption = 'Up'<br />
TabOrder = 0<br />
OnClick = Button_dim_upClick<br />
end<br />
object Button_dim_down: TButton<br />
Left = 8<br />
Top = 42<br />
Width = 50<br />
Height = 25<br />
Caption = 'Down'<br />
TabOrder = 1<br />
OnClick = Button_dim_downClick<br />
end<br />
end<br />
object APA_hierbox: TGroupBox<br />
Left = 1<br />
Top = 73<br />
Width = 63<br />
Height = 73<br />
Align = alTop<br />
Caption = 'Hierarchy'<br />
Enabled = False<br />
TabOrder = 1<br />
object button_hier_up: TButton<br />
Left = 8<br />
Top = 16<br />
Width = 50<br />
Height = 25<br />
Caption = 'Up'<br />
TabOrder = 0<br />
OnClick = button_hier_upClick<br />
end<br />
object Button_hier_down: TButton<br />
Left = 8<br />
Top = 42<br />
Width = 50<br />
Height = 25<br />
Caption = 'Down'<br />
TabOrder = 1<br />
OnClick = Button_hier_downClick<br />
end<br />
end<br />
end<br />
object GroupBox1: TGroupBox<br />
Left = 0<br />
Top = 381<br />
Width = 596<br />
Height = 112<br />
Align = alBottom<br />
Caption = 'Key figures'<br />
TabOrder = 3<br />
object Panel4: TPanel<br />
Left = 2<br />
Top = 15<br />
Width = 95<br />
Height = 95<br />
Align = alLeft<br />
TabOrder = 0<br />
object Button_key_insert: TButton<br />
Left = 5<br />
Top = 7<br />
Width = 75<br />
Height = 25<br />
Caption = 'Insert'<br />
TabOrder = 0<br />
OnClick = Button_key_insertClick<br />
end<br />
object Button_key_edit: TButton<br />
Left = 5<br />
Top = 35<br />
Width = 75<br />
Height = 25<br />
- 399 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Caption = 'Edit'<br />
TabOrder = 1<br />
OnClick = Button_key_editClick<br />
end<br />
object Button_key_delete: TButton<br />
Left = 5<br />
Top = 62<br />
Width = 75<br />
Height = 25<br />
Caption = 'Delete'<br />
TabOrder = 2<br />
OnClick = Button_key_deleteClick<br />
end<br />
end<br />
object Keybox: TListBox<br />
Left = 97<br />
Top = 15<br />
Width = 497<br />
Height = 95<br />
Align = alClient<br />
ItemHeight = 13<br />
Items.Strings = (<br />
'Profit//SUM(MONEY)'<br />
'')<br />
TabOrder = 1<br />
OnDblClick = KeyboxDblClick<br />
end<br />
end<br />
object Eingabe: TTreeView<br />
Left = 65<br />
Top = 41<br />
Width = 531<br />
Height = 340<br />
Align = alClient<br />
Font.Charset = DEFAULT_CHARSET<br />
Font.Color = clWindowText<br />
Font.Height = -13<br />
Font.Name = 'MS Sans Serif'<br />
Font.Style = []<br />
HideSelection = False<br />
Images = APA_ImageList<br />
Indent = 19<br />
ParentFont = False<br />
ReadOnly = True<br />
TabOrder = 4<br />
OnClick = EingabeClick<br />
OnMouseUp = EingabeMouseUp<br />
Items.Data = {<br />
010000001D000000010000000100000001000000FFFFFFFF0000000004000000<br />
0454696D6527000000020000000200000002000000FFFFFFFF00000000000000<br />
000E5A5F642F2F5461673A3A3336353028000000020000000200000002000000<br />
FFFFFFFF00000000000000000F5A5F6D2F2F4D6F6E74683A3A31323026000000<br />
020000000200000002000000FFFFFFFF00000000000000000D5A5F792F2F5965<br />
61723A3A31302B000000020000000200000002000000FFFFFFFF000000000000<br />
0000125A5F2A2F2F54696D6520746F74616C3A3A31}<br />
end<br />
object Eingabemerk: TTreeView<br />
Left = 432<br />
Top = 272<br />
Width = 97<br />
Height = 57<br />
Indent = 19<br />
TabOrder = 5<br />
Visible = False<br />
end<br />
object Keyboxmerk: TListBox<br />
Left = 448<br />
Top = 160<br />
Width = 81<br />
Height = 57<br />
ItemHeight = 13<br />
TabOrder = 6<br />
Visible = False<br />
end<br />
- 400 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
object APA_popup: TPopupMenu<br />
Left = 424<br />
Top = 64<br />
object Insertdimension1: TMenuItem<br />
Caption = 'Insert dimension'<br />
OnClick = Insertdimension1Click<br />
end<br />
object Inserthierarchy1: TMenuItem<br />
Caption = 'Insert hierarchy'<br />
OnClick = Inserthierarchy1Click<br />
end<br />
object Delete1: TMenuItem<br />
Caption = 'Delete'<br />
OnClick = Delete1Click<br />
end<br />
object Edit1: TMenuItem<br />
Caption = 'Edit'<br />
OnClick = Edit1Click<br />
end<br />
object N1: TMenuItem<br />
Caption = '-'<br />
end<br />
object Dimensionup1: TMenuItem<br />
Caption = 'Dimension up'<br />
OnClick = Dimensionup1Click<br />
end<br />
object Dimensiondown1: TMenuItem<br />
Caption = 'Dimension down'<br />
OnClick = Dimensiondown1Click<br />
end<br />
object N2: TMenuItem<br />
Caption = '-'<br />
end<br />
object Hierarchyup1: TMenuItem<br />
Caption = 'Hierarchy up'<br />
OnClick = Hierarchyup1Click<br />
end<br />
object Hierarchydown1: TMenuItem<br />
Caption = 'Hierarchy down'<br />
ImageIndex = 0<br />
OnClick = Hierarchydown1Click<br />
end<br />
end<br />
object APA_ImageList: TImageList<br />
Left = 504<br />
Top = 72<br />
Bitmap = {<br />
494C010103000400040010001000FFFFFFFFFF10FFFFFFFFFFFFFFFF424D3600<br />
0000000000003600000028000000400000001000000001002000000000000010<br />
000000000000000000000000000000000000344E4A006BB09B006BB09B006BB0<br />
. . .<br />
. . .<br />
0000800100010000000080010001000000008001000100000000800100010000<br />
0000800100010000000080010001000000008001000100000000800100010000<br />
00008001000100000000FFFFFFFF000000000000000000000000000000000000<br />
000000000000}<br />
end<br />
end<br />
12.1.19 UNIT APA_INPUT_SCREENUNIT.PAS<br />
unit APA_Input_Screenunit;<br />
interface<br />
uses<br />
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,<br />
Dialogs, ImgList, ComCtrls, Menus, StdCtrls, ExtCtrls;<br />
type<br />
TAPA_Input_Screen = class(TForm)<br />
Panel1: TPanel;<br />
- 401 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Saveandexit_button: TButton;<br />
Abortandexit_button: TButton;<br />
Panel2: TPanel;<br />
Button_insert_dimension: TButton;<br />
Button_delete: TButton;<br />
Button_Edit: TButton;<br />
Button_insert_hierarchy: TButton;<br />
Panel3: TPanel;<br />
APA_dimbox: TGroupBox;<br />
Button_dim_up: TButton;<br />
Button_dim_down: TButton;<br />
APA_hierbox: TGroupBox;<br />
button_hier_up: TButton;<br />
Button_hier_down: TButton;<br />
GroupBox1: TGroupBox;<br />
Panel4: TPanel;<br />
Button_key_insert: TButton;<br />
Button_key_edit: TButton;<br />
Button_key_delete: TButton;<br />
Keybox: TListBox;<br />
APA_popup: TPopupMenu;<br />
Insertdimension1: TMenuItem;<br />
Inserthierarchy1: TMenuItem;<br />
Delete1: TMenuItem;<br />
Edit1: TMenuItem;<br />
N1: TMenuItem;<br />
Dimensionup1: TMenuItem;<br />
Dimensiondown1: TMenuItem;<br />
N2: TMenuItem;<br />
Hierarchyup1: TMenuItem;<br />
Hierarchydown1: TMenuItem;<br />
Eingabe: TTreeView;<br />
APA_ImageList: TImageList;<br />
Eingabemerk: TTreeView;<br />
Keyboxmerk: TListBox;<br />
procedure Button_insert_dimensionClick(Sender: TObject);<br />
procedure Button_EditClick(Sender: TObject);<br />
procedure Button_deleteClick(Sender: TObject);<br />
procedure Button_insert_hierarchyClick(Sender: TObject);<br />
procedure Delete1Click(Sender: TObject);<br />
procedure Insertdimension1Click(Sender: TObject);<br />
procedure Inserthierarchy1Click(Sender: TObject);<br />
procedure Edit1Click(Sender: TObject);<br />
procedure Dimensionup1Click(Sender: TObject);<br />
procedure Dimensiondown1Click(Sender: TObject);<br />
procedure Hierarchyup1Click(Sender: TObject);<br />
procedure Hierarchydown1Click(Sender: TObject);<br />
procedure Button_dim_upClick(Sender: TObject);<br />
procedure Button_dim_downClick(Sender: TObject);<br />
procedure button_hier_upClick(Sender: TObject);<br />
procedure Button_hier_downClick(Sender: TObject);<br />
procedure Saveandexit_buttonClick(Sender: TObject);<br />
procedure EingabeClick(Sender: TObject);<br />
procedure EingabeMouseUp(Sender: TObject; Button: TMouseButton;<br />
Shift: TShiftState; X, Y: Integer);<br />
procedure Button_key_insertClick(Sender: TObject);<br />
procedure Button_key_deleteClick(Sender: TObject);<br />
procedure Button_key_editClick(Sender: TObject);<br />
procedure KeyboxDblClick(Sender: TObject);<br />
procedure Abortandexit_buttonClick(Sender: TObject);<br />
procedure FormShow(Sender: TObject);<br />
procedure FormCloseQuery(Sender: TObject; var CanClose: Boolean);<br />
private<br />
{ Private-Deklarationen }<br />
public<br />
{ Public-Deklarationen }<br />
end;<br />
var<br />
APA_Input_Screen: TAPA_Input_Screen;<br />
generiereapaneu:boolean=true;<br />
implementation<br />
uses APA_Input_Dimensionunit, APA_Input_Hierarchyunit, APA_Keyunit, APA_Gridunit,<br />
- 402 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
APA_Applicationunit, APA_Dialogunit;<br />
{$R *.dfm}<br />
var neuekosten:boolean;<br />
procedure TAPA_Input_Screen.Button_insert_dimensionClick(Sender: TObject);<br />
var merkex:longint;<br />
var ok:boolean;<br />
begin<br />
mustsave:=true;<br />
if (Eingabe.SelectedNil) then begin<br />
{Setze den Zeiger auf eine Dimension oder auf das erste Element}<br />
while (Eingabe.Selected.ImageIndex1)and(Eingabe.Selected.GetPrevnil) do<br />
Eingabe.Selected:=Eingabe.Selected.GetPrev;<br />
end;<br />
{Eine Dimension}<br />
APA_Insert_Dimension.Dimension.Text:='';<br />
APA_Insert_Dimension.OKBtn.Enabled:=false;<br />
repeat;<br />
ok:=true;<br />
if APA_Insert_Dimension.showmodal=mrOK then begin<br />
for merkex:=0 to Eingabe.Items.Count-1 do begin<br />
if Eingabe.Items[merkex].ImageIndex=1 then begin<br />
if Eingabe.Items[merkex].Text=APA_Insert_Dimension.Dimension.Text then begin<br />
showmessage('The name '+APA_Insert_Dimension.Dimension.Text+' for a dimension is<br />
already used. Please change the name!');<br />
ok:=false;<br />
end;<br />
end;<br />
end;<br />
if ok=true then begin<br />
merkex:=Eingabe.Items.Add(Eingabe.Selected,APA_Insert_Dimension.Dimension.Text).Ab<br />
soluteIndex;<br />
Eingabe.Items[merkex].ImageIndex:=1;<br />
Eingabe.Items[merkex].SelectedIndex:=1;<br />
Saveandexit_button.Enabled:=true;<br />
generiereapaneu:=true;<br />
end;<br />
end else ok:=true;<br />
until ok=true;<br />
{Eine Dimension ENDE}<br />
Eingabeclick(self);<br />
if (Eingabe.SelectedNil) then Eingabe.Selected.Expanded:=true;<br />
end;<br />
procedure TAPA_Input_Screen.Button_EditClick(Sender: TObject);<br />
var ok:boolean;<br />
var merkex:longint;<br />
begin<br />
mustsave:=true;<br />
if (Eingabe.Selected.ImageIndex=1) then begin<br />
{Eine Dimension}<br />
APA_Insert_Dimension.Dimension.Text:=Eingabe.Selected.Text;<br />
APA_Insert_Dimension.OKBtn.Enabled:=false;<br />
repeat;<br />
ok:=true;<br />
if APA_Insert_Dimension.showmodal=mrOK then begin<br />
for merkex:=0 to Eingabe.Items.Count-1 do begin<br />
if Eingabe.Items[merkex].ImageIndex=1 then begin<br />
if (Eingabe.Items[merkex].Text=APA_Insert_Dimension.Dimension.Text)and<br />
(merkexEingabe.Selected.AbsoluteIndex)<br />
then begin<br />
showmessage('The name '+APA_Insert_Dimension.Dimension.Text+' for a dimension is<br />
already used. Please change the name!');<br />
ok:=false;<br />
- 403 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
end;<br />
end;<br />
end;<br />
if ok=true then begin<br />
Eingabe.Selected.Text:=APA_Insert_Dimension.Dimension.Text;<br />
Saveandexit_button.Enabled:=true;<br />
generiereapaneu:=true;<br />
end;<br />
end else ok:=true;<br />
until ok=true;<br />
{Eine Dimension ENDE}<br />
end else begin<br />
{Eine Hierarchy}<br />
APA_Insert_Hierarchy.short_hierarchy.Text:=<br />
copy(Eingabe.Selected.Text,1,pos('//',Eingabe.Selected.Text)-1);<br />
APA_Insert_Hierarchy.long_hierarchy.Text:=<br />
copy(Eingabe.Selected.Text,pos('//',Eingabe.Selected.Text)+2,pos('::',Eingabe.Sele<br />
cted.Text)-(pos('//',Eingabe.Selected.Text)+2));<br />
APA_Insert_Hierarchy.datarecords.Text:=<br />
copy(Eingabe.Selected.Text,pos('::',Eingabe.Selected.Text)+2,255);<br />
APA_Insert_Hierarchy.OKBtn.Enabled:=false;<br />
repeat;<br />
ok:=true;<br />
if APA_Insert_Hierarchy.showmodal=mrOK then begin<br />
for merkex:=0 to Eingabe.Items.Count-1 do begin<br />
if Eingabe.Items[merkex].ImageIndex=2 then begin<br />
if (copy(Eingabe.Items[merkex].Text,1,pos('//',Eingabe.Items[merkex].Text)-<br />
1)=APA_Insert_Hierarchy.short_hierarchy.Text)and<br />
(merkexEingabe.Selected.AbsoluteIndex) then begin<br />
showmessage('The name '+APA_Insert_Hierarchy.short_hierarchy.Text+' for a short<br />
hierarchy is already used. Please change the name!');<br />
ok:=false;<br />
end;<br />
end;<br />
end;<br />
if ok=true then begin<br />
Eingabe.Selected.Text:=<br />
APA_Insert_Hierarchy.short_hierarchy.Text+'//'+APA_Insert_Hierarchy.long_hierarchy<br />
.Text+'::'+<br />
APA_Insert_Hierarchy.datarecords.Text;<br />
Saveandexit_button.Enabled:=true;<br />
generiereapaneu:=true;<br />
end;<br />
end else ok:=true;<br />
until ok=true;<br />
{Eine Hierarchy ENDE}<br />
end;<br />
Eingabeclick(self);<br />
end;<br />
procedure TAPA_Input_Screen.Button_deleteClick(Sender: TObject);<br />
begin<br />
mustsave:=true;<br />
if Eingabe.Selectednil then begin<br />
if Eingabe.Selected.ImageIndex=2 then neuekosten:=true;<br />
Eingabe.Items.Delete(Eingabe.Selected);<br />
Saveandexit_button.Enabled:=true;<br />
generiereapaneu:=true;<br />
end else showmessage('No dimension or hierarchy selected.');<br />
Eingabeclick(self);<br />
end;<br />
procedure TAPA_Input_Screen.Button_insert_hierarchyClick(Sender: TObject);<br />
var merkex:longint;<br />
- 404 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
var ok:boolean;<br />
var counter,merkdatacount,merkdatacount2:longint;<br />
var merketext1,merketext2:string;<br />
begin<br />
mustsave:=true;<br />
if Eingabe.Selectednil then begin<br />
{Eine Hierarchy}<br />
APA_Insert_Hierarchy.short_hierarchy.Text:='';<br />
APA_Insert_Hierarchy.long_hierarchy.Text:='';<br />
APA_Insert_Hierarchy.OKBtn.Enabled:=false;<br />
repeat;<br />
ok:=true;<br />
if APA_Insert_Hierarchy.showmodal=mrOK then begin<br />
for merkex:=0 to Eingabe.Items.Count-1 do begin<br />
if Eingabe.Items[merkex].ImageIndex=2 then begin<br />
if copy(Eingabe.Items[merkex].Text,1,pos('//',Eingabe.Items[merkex].Text)-<br />
1)=APA_Insert_Hierarchy.short_hierarchy.Text then begin<br />
showmessage('The name '+APA_Insert_Hierarchy.short_hierarchy.Text+' for a short<br />
hierarchy is already used. Please change the name!');<br />
ok:=false;<br />
end;<br />
end;<br />
end;<br />
if ok=true then begin<br />
if Eingabe.Selected.ImageIndex=1 then begin;<br />
{wenn Dimension markiert}<br />
merkex:=Eingabe.Items.AddChild(Eingabe.Selected,<br />
APA_Insert_Hierarchy.short_hierarchy.Text+'//'+APA_Insert_Hierarchy.long_hierarchy<br />
.Text<br />
+'::'+APA_Insert_Hierarchy.datarecords.Text).AbsoluteIndex;<br />
Eingabe.Items[merkex].ImageIndex:=2;<br />
Eingabe.Items[merkex].SelectedIndex:=2;<br />
end<br />
else<br />
{wenn Hierarchy markiert}<br />
merkex:=Eingabe.Items.Add(Eingabe.Selected,<br />
APA_Insert_Hierarchy.short_hierarchy.Text+'//'+APA_Insert_Hierarchy.long_hierarchy<br />
.Text<br />
+'::'+APA_Insert_Hierarchy.datarecords.Text).AbsoluteIndex;<br />
Eingabe.Items[merkex].ImageIndex:=2;<br />
Eingabe.Items[merkex].SelectedIndex:=2;<br />
Saveandexit_button.Enabled:=true;<br />
generiereapaneu:=true;<br />
neuekosten:=true;<br />
end;//von ok<br />
end else ok:=true;<br />
until ok=true;<br />
{Eine Hierarchy ENDE}<br />
end else showmessage('No Item selected!');<br />
Eingabeclick(self);<br />
if (Eingabe.SelectedNil) then Eingabe.Selected.Expanded:=true;<br />
//Sortieren der Hierarchien<br />
counter:=0;<br />
repeat;<br />
if (counter
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
end;<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
merkdatacount2:=strtoint(copy(Eingabe.Items[counter+1].Text,pos('::',Eingabe.Items<br />
[counter+1].Text)+2,255));<br />
if merkdatacount
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Eingabeclick(self);<br />
Saveandexit_button.Enabled:=true;<br />
generiereapaneu:=true;<br />
Eingabe.Repaint;<br />
end;<br />
procedure TAPA_Input_Screen.Button_dim_downClick(Sender: TObject);<br />
begin<br />
mustsave:=true;<br />
if Eingabe.Selectednil then<br />
if Eingabe.Selected.ImageIndex=1 then<br />
if Eingabe.Selected.getNextSiblingnil then<br />
if Eingabe.Selected.getNextSibling.ImageIndex=1 then<br />
Eingabe.Selected.getNextSibling.MoveTo(Eingabe.Selected,naInsert);<br />
Eingabeclick(self);<br />
Saveandexit_button.Enabled:=true;<br />
generiereapaneu:=true;<br />
end;<br />
procedure TAPA_Input_Screen.button_hier_upClick(Sender: TObject);<br />
var merke1,merke2:string;<br />
begin<br />
mustsave:=true;<br />
if Eingabe.Selectednil then<br />
if Eingabe.Selected.ImageIndex=2 then<br />
if Eingabe.Selected.GetPrevNil then<br />
if (Eingabe.Selected.GetPrev.ImageIndex=2) then begin;<br />
merke1:=Eingabe.Selected.Text;<br />
merke2:=Eingabe.Selected.getprev.Text;<br />
if strtoint(copy(merke2,pos('::',merke2)+2,255))><br />
strtoint(copy(merke1,pos('::',merke1)+2,255)) then<br />
begin;<br />
Eingabe.Selected.Text:=copy(merke1,1,pos('::',merke1)+1)+<br />
copy(merke2,pos('::',merke2)+2,255);<br />
Eingabe.Selected.Getprev.Text:=copy(merke2,1,pos('::',merke2)+1)+<br />
copy(merke1,pos('::',merke1)+2,255);<br />
end;<br />
Eingabe.Selected.MoveTo(Eingabe.Selected.GetPrev,naInsert);<br />
end;<br />
Eingabeclick(self);<br />
Saveandexit_button.Enabled:=true;<br />
generiereapaneu:=true;<br />
end;<br />
procedure TAPA_Input_Screen.Button_hier_downClick(Sender: TObject);<br />
var merke1,merke2:string;<br />
begin<br />
mustsave:=true;<br />
if Eingabe.Selectednil then<br />
if Eingabe.Selected.ImageIndex=2 then<br />
If Eingabe.Selected.GetNextnil then<br />
If Eingabe.Selected.GetNext.ImageIndex=2 then begin;<br />
merke1:=Eingabe.Selected.Text;<br />
merke2:=Eingabe.Selected.getnext.Text;<br />
if strtoint(copy(merke2,pos('::',merke2)+2,255))<<br />
strtoint(copy(merke1,pos('::',merke1)+2,255)) then<br />
begin;<br />
Eingabe.Selected.Text:=copy(merke1,1,pos('::',merke1)+1)+<br />
copy(merke2,pos('::',merke2)+2,255);<br />
Eingabe.Selected.GetNext.Text:=copy(merke2,1,pos('::',merke2)+1)+<br />
copy(merke1,pos('::',merke1)+2,255);<br />
- 407 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
end;<br />
Eingabe.Selected.GetNext.MoveTo(Eingabe.Selected,naInsert);<br />
end;<br />
Eingabeclick(self);<br />
Saveandexit_button.Enabled:=true;<br />
generiereapaneu:=true;<br />
end;<br />
procedure buttonchange;<br />
begin;<br />
with APA_Input_Screen do begin<br />
if Eingabe.Selectednil then begin<br />
if Eingabe.Selected.ImageIndex=1 then begin<br />
{dimension}<br />
APA_dimbox.Enabled:=true;<br />
APA_hierbox.Enabled:=false;<br />
If Eingabe.Selected.getPrevSiblingnil then<br />
Button_dim_up.Enabled:=true else Button_dim_up.Enabled:=false;<br />
If Eingabe.Selected.getNextSiblingnil then<br />
Button_dim_down.Enabled:=true else Button_dim_down.Enabled:=false;<br />
button_hier_up.Enabled:=false;<br />
Button_hier_down.Enabled:=false;<br />
end else<br />
begin<br />
{Hierarchy}<br />
APA_dimbox.Enabled:=false;<br />
APA_hierbox.Enabled:=true;<br />
Button_dim_up.Enabled:=false;<br />
Button_dim_down.Enabled:=false;<br />
If Eingabe.Selected.getPrevSiblingnil then<br />
Button_hier_up.Enabled:=true else Button_hier_up.Enabled:=false;<br />
If Eingabe.Selected.getNextSiblingnil then<br />
Button_hier_down.Enabled:=true else Button_hier_down.Enabled:=false;<br />
end;<br />
end else<br />
begin<br />
APA_dimbox.Enabled:=false;<br />
APA_hierbox.Enabled:=false;<br />
Button_dim_up.Enabled:=false;<br />
Button_dim_down.Enabled:=false;<br />
button_hier_up.Enabled:=false;<br />
Button_hier_down.Enabled:=false;<br />
end;<br />
end;<br />
end;<br />
procedure TAPA_Input_Screen.Saveandexit_buttonClick(Sender: TObject);<br />
var counter,maxchilds,merkdatacount:longint;<br />
CurItem,lastdim,nrmaxchilds:TTreeNode;<br />
begin<br />
Saveandexit_button.Enabled:=false;<br />
mustsave:=true;<br />
//Überprüfe die richte Anordung der Hierarchien<br />
merkdatacount:=0;<br />
for counter:=0 to Eingabe.Items.Count-1 do begin<br />
If Eingabe.Items[counter].ImageIndex=1 then begin<br />
//Wert neu<br />
merkdatacount:=0;<br />
end else begin<br />
if ((merkdatacount=0)or<br />
(merkdatacount><br />
strtoint(copy(Eingabe.Items[counter].Text,pos('::',Eingabe.Items[counter].Text)+2,<br />
255))))<br />
then begin<br />
- 408 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
end;<br />
end;<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
merkdatacount:=strtoint(copy(Eingabe.Items[counter].Text,pos('::',Eingabe.Items[co<br />
unter].Text)+2,255));<br />
end else begin<br />
//Fehler<br />
showmessage('Hierarchies are not in right order. Please check '+<br />
copy(Eingabe.Items[counter].Text,pos('//',Eingabe.Items[counter].Text)+2,<br />
pos('::',Eingabe.Items[counter].Text)-(pos('//',Eingabe.Items[counter].Text)+2)));<br />
exit;<br />
end;<br />
if generiereapaneu=true then begin<br />
{Setze die Dimension mit den meisten Unterknoten nach unten}<br />
lastdim:=nil;<br />
CurItem:=Eingabe.Items.GetFirstNode;nrmaxchilds:=CurItem;<br />
while nrmaxchildslastdim do begin<br />
CurItem:=Eingabe.Items.GetFirstNode;nrmaxchilds:=CurItem;<br />
maxchilds:=0;<br />
while CurItemnil do begin<br />
if maxchilds
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
mustsave:=true;<br />
Saveandexit_button.Enabled:=true;<br />
mustsave:=true;<br />
APA_Insert_Key.Key_Fieldname.Text:='';<br />
APA_Insert_Key.APA_Function.ItemIndex:=0;<br />
APA_Insert_Key.APA_Field_type.ItemIndex:=4;<br />
APA_Insert_Key.OKBtn.enabled:=false;<br />
repeat;<br />
ok:=true;<br />
if APA_Insert_Key.showmodal=mrOK then begin<br />
for counter:=0 to Keybox.Items.Count-1 do begin<br />
if (APA_Insert_Key.Key_fieldname.Text=<br />
copy(Keybox.items[counter],1,pos('//',Keybox.items[counter])-1)) then begin<br />
ok:=false;<br />
showmessage('The name '+APA_Insert_Key.Key_fieldname.Text+' is already used.<br />
Please change the name!');<br />
end;<br />
end;<br />
if ok=true then begin<br />
Keybox.Items.Add(APA_Insert_Key.Key_fieldname.Text+'//'+APA_Insert_Key.APA_Functio<br />
n.Items[APA_Insert_Key.APA_Function.itemindex]<br />
+'('+APA_Insert_Key.APA_Field_type.Items[APA_Insert_Key.APA_Field_type.itemindex]+<br />
')');<br />
Saveandexit_button.Enabled:=true;<br />
end;<br />
end else ok:=true;<br />
until ok=true;<br />
end;<br />
procedure TAPA_Input_Screen.Button_key_deleteClick(Sender: TObject);<br />
begin<br />
mustsave:=true;<br />
if keybox.ItemIndex-1 then begin<br />
Saveandexit_button.Enabled:=true;<br />
Keybox.Items.Delete(Keybox.ItemIndex);<br />
mustsave:=true;<br />
end<br />
else<br />
showmessage('No Key figure selected');<br />
end;<br />
procedure TAPA_Input_Screen.Button_key_editClick(Sender: TObject);<br />
var ok:boolean;<br />
counter:longint;<br />
begin<br />
mustsave:=true;<br />
if Keybox.ItemIndex-1 then begin<br />
APA_Insert_Key.APA_Function.ItemIndex:=<br />
APA_Insert_Key.APA_Function.Items.IndexOf(copy(Keybox.items[Keybox.itemindex],pos(<br />
'//',<br />
Keybox.items[Keybox.itemindex])+2,3));<br />
APA_Insert_Key.Key_fieldname.Text:=<br />
copy(Keybox.items[Keybox.itemindex],1,pos('//',Keybox.items[Keybox.itemindex])-1);<br />
APA_Insert_Key.APA_Field_type.ItemIndex:=<br />
APA_Insert_Key.APA_Field_type.Items.IndexOf(<br />
copy(Keybox.items[Keybox.itemindex],pos('//',Keybox.items[Keybox.itemindex])+6,<br />
length(Keybox.items[Keybox.itemindex])-(pos('//',Keybox.items[Keybox.itemindex])+6)));<br />
APA_Insert_Key.OKBtn.enabled:=false;<br />
repeat;<br />
ok:=true;<br />
if APA_Insert_Key.showmodal=mrOK then begin<br />
for counter:=0 to Keybox.Items.Count-1 do begin<br />
if (APA_Insert_Key.Key_fieldname.Text=<br />
copy(Keybox.items[counter],1,pos('//',Keybox.items[counter])-1))<br />
- 410 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
and(counterKeybox.ItemIndex)<br />
then begin<br />
ok:=false;<br />
showmessage('The name '+APA_Insert_Key.Key_fieldname.Text+' is already used.<br />
Please change the name!');<br />
end;<br />
end;<br />
if ok=true then begin<br />
Keybox.Items[Keybox.ItemIndex]:=APA_Insert_Key.Key_fieldname.Text+'//'+<br />
APA_Insert_Key.APA_Function.Items[APA_Insert_Key.APA_Function.itemindex]<br />
+'('+APA_Insert_Key.APA_Field_type.Items[APA_Insert_Key.APA_Field_type.itemindex]+<br />
')';<br />
Saveandexit_button.Enabled:=true; mustsave:=true;<br />
end;<br />
end else ok:=true;<br />
until ok=true;<br />
end<br />
else showmessage('No Key figure selected');<br />
end;<br />
procedure TAPA_Input_Screen.KeyboxDblClick(Sender: TObject);<br />
begin<br />
Button_key_edit.click;<br />
end;<br />
procedure TAPA_Input_Screen.Abortandexit_buttonClick(Sender: TObject);<br />
begin<br />
Saveandexit_button.Enabled:=false;<br />
keybox.Items.Clear;<br />
keybox.Items:=keyboxmerk.Items;<br />
Eingabe.Items.Clear;<br />
Eingabe.Items:=Eingabemerk.Items;<br />
end;<br />
procedure TAPA_Input_Screen.FormShow(Sender: TObject);<br />
begin<br />
//Speichere die aktuellen Eingabe<br />
keyboxmerk.Items.Clear;<br />
keyboxmerk.Items:=keybox.Items;<br />
Eingabemerk.Items.Clear;<br />
Eingabemerk.Items:=Eingabe.Items;<br />
neuekosten:=false;<br />
end;<br />
procedure TAPA_Input_Screen.FormCloseQuery(Sender: TObject;<br />
var CanClose: Boolean);<br />
var counter, merkcounter:longint;<br />
ok:boolean;<br />
begin<br />
{Kontrolliere, ob jede Dimension mindestens eine Hierarchie hat}<br />
ok:=true;merkcounter:=0;<br />
for counter:=0 to Eingabe.Items.Count-1 do begin<br />
if Eingabe.Items[counter].ImageIndex=1 then begin<br />
//wenn Dimension<br />
if ok=false //dann gibt es eine Hierarchie<br />
then begin<br />
showmessage('The dimension '+Eingabe.Items[merkcounter].Text+' do not have a<br />
hierarchy');<br />
canClose:=false;<br />
end;<br />
ok:=false; merkcounter:=counter;<br />
end else begin<br />
//wenn Hierarchie<br />
ok:=true;<br />
- 411 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
end;<br />
end;<br />
if Saveandexit_button.Enabled=true then begin<br />
APA_Dialog.APA_Text.Caption:='Do you want to save your changes?';<br />
if APA_Dialog.showmodal=mryes then Saveandexit_button.Click else<br />
Abortandexit_button.Click;<br />
end;<br />
end;<br />
end.<br />
12.1.20 UNIT APA_KEYUNIT.DFM<br />
object APA_Insert_Key: TAPA_Insert_Key<br />
Left = 234<br />
Top = 185<br />
ActiveControl = Key_fieldname<br />
BorderStyle = bsDialog<br />
Caption = 'APA Insert Key'<br />
ClientHeight = 205<br />
ClientWidth = 321<br />
Color = clBtnFace<br />
Font.Charset = DEFAULT_CHARSET<br />
Font.Color = clWindowText<br />
Font.Height = -11<br />
Font.Name = 'MS Sans Serif'<br />
Font.Style = []<br />
OldCreateOrder = False<br />
Position = poScreenCenter<br />
OnShow = FormShow<br />
PixelsPerInch = 96<br />
TextHeight = 13<br />
object Bevel1: TBevel<br />
Left = 12<br />
Top = 16<br />
Width = 297<br />
Height = 145<br />
Shape = bsFrame<br />
end<br />
object Label1: TLabel<br />
Left = 28<br />
Top = 25<br />
Width = 48<br />
Height = 13<br />
Caption = 'Fieldname'<br />
end<br />
object Label2: TLabel<br />
Left = 28<br />
Top = 110<br />
Width = 42<br />
Height = 13<br />
Caption = 'Fieldtype'<br />
end<br />
object Label3: TLabel<br />
Left = 28<br />
Top = 66<br />
Width = 41<br />
Height = 13<br />
Caption = 'Function'<br />
end<br />
object OKBtn: TButton<br />
Left = 83<br />
Top = 172<br />
Width = 75<br />
Height = 25<br />
Caption = 'OK'<br />
Default = True<br />
Enabled = False<br />
ModalResult = 1<br />
- 412 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
TabOrder = 1<br />
OnClick = OKBtnClick<br />
end<br />
object CancelBtn: TButton<br />
Left = 163<br />
Top = 172<br />
Width = 75<br />
Height = 25<br />
Cancel = True<br />
Caption = 'Cancel'<br />
ModalResult = 2<br />
TabOrder = 2<br />
end<br />
object Key_fieldname: TEdit<br />
Left = 28<br />
Top = 41<br />
Width = 257<br />
Height = 21<br />
MaxLength = 40<br />
TabOrder = 0<br />
OnChange = Key_fieldnameChange<br />
end<br />
object APA_Field_type: TComboBox<br />
Left = 28<br />
Top = 126<br />
Width = 249<br />
Height = 21<br />
Style = csDropDownList<br />
ItemHeight = 13<br />
ItemIndex = 0<br />
TabOrder = 3<br />
Text = 'BIGINT'<br />
OnChange = APA_Field_typeChange<br />
Items.Strings = (<br />
'BIGINT'<br />
'INT'<br />
'SMALLINT'<br />
'DECIMAL'<br />
'MONEY'<br />
'SMALLMONEY'<br />
'FLOAT'<br />
'REAL'<br />
'DATETIME'<br />
'SMALLDATETIME')<br />
end<br />
object APA_Function: TComboBox<br />
Left = 28<br />
Top = 82<br />
Width = 145<br />
Height = 21<br />
Style = csDropDownList<br />
ItemHeight = 13<br />
ItemIndex = 0<br />
TabOrder = 4<br />
Text = 'SUM'<br />
OnChange = APA_FunctionChange<br />
Items.Strings = (<br />
'SUM'<br />
'MAX'<br />
'MIN'<br />
'COUNT')<br />
end<br />
end<br />
12.1.21 UNIT APA_KEYUNIT.PAS<br />
unit APA_Keyunit;<br />
interface<br />
uses<br />
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,<br />
- 413 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Dialogs, Spin, StdCtrls, ExtCtrls;<br />
type<br />
TAPA_Insert_Key = class(TForm)<br />
Bevel1: TBevel;<br />
OKBtn: TButton;<br />
CancelBtn: TButton;<br />
Label1: TLabel;<br />
Key_fieldname: TEdit;<br />
Label2: TLabel;<br />
APA_Field_type: TComboBox;<br />
Label3: TLabel;<br />
APA_Function: TComboBox;<br />
procedure Key_fieldnameChange(Sender: TObject);<br />
procedure OKBtnClick(Sender: TObject);<br />
procedure FormShow(Sender: TObject);<br />
procedure APA_FunctionChange(Sender: TObject);<br />
procedure APA_Field_typeChange(Sender: TObject);<br />
private<br />
{ Private-Deklarationen }<br />
public<br />
{ Public-Deklarationen }<br />
end;<br />
var<br />
APA_Insert_Key: TAPA_Insert_Key;<br />
implementation<br />
{$R *.dfm}<br />
procedure TAPA_Insert_Key.Key_fieldnameChange(Sender: TObject);<br />
begin<br />
OKBtn.Enabled:=true;<br />
end;<br />
procedure TAPA_Insert_Key.OKBtnClick(Sender: TObject);<br />
var st:string;<br />
begin<br />
if (pos('//',Key_Fieldname.Text)0) then begin;<br />
showmessage('Sting "//" is not allowed in Fieldname');<br />
st:=Key_Fieldname.Text;<br />
delete(st,pos('//',st),2);<br />
Key_Fieldname.Text:=st;<br />
end;<br />
end;<br />
procedure TAPA_Insert_Key.FormShow(Sender: TObject);<br />
begin<br />
Key_Fieldname.SetFocus;<br />
end;<br />
procedure TAPA_Insert_Key.APA_FunctionChange(Sender: TObject);<br />
begin<br />
OKBtn.Enabled:=true;<br />
end;<br />
procedure TAPA_Insert_Key.APA_Field_typeChange(Sender: TObject);<br />
begin<br />
OKBtn.Enabled:=true;<br />
end;<br />
end.<br />
12.1.22 UNIT APA_OPTIONSUNIT.DFM<br />
object APA_Options: TAPA_Options<br />
Left = 223<br />
Top = 134<br />
Width = 454<br />
- 414 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Height = 387<br />
Caption = 'APA Options'<br />
Color = clBtnFace<br />
Font.Charset = DEFAULT_CHARSET<br />
Font.Color = clWindowText<br />
Font.Height = -11<br />
Font.Name = 'MS Sans Serif'<br />
Font.Style = []<br />
OldCreateOrder = False<br />
Position = poScreenCenter<br />
PixelsPerInch = 96<br />
TextHeight = 13<br />
object Panel1: TPanel<br />
Left = 0<br />
Top = 312<br />
Width = 446<br />
Height = 41<br />
Align = alBottom<br />
TabOrder = 0<br />
object Button1: TButton<br />
Left = 186<br />
Top = 8<br />
Width = 75<br />
Height = 25<br />
Cancel = True<br />
Caption = 'Close'<br />
Default = True<br />
TabOrder = 0<br />
OnClick = Button1Click<br />
end<br />
end<br />
object PageControl1: TPageControl<br />
Left = 0<br />
Top = 0<br />
Width = 446<br />
Height = 312<br />
ActivePage = APA_On_Start<br />
Align = alClient<br />
TabOrder = 1<br />
object APA_On_Start: TTabSheet<br />
Caption = 'On Start'<br />
object APA_Load_Last_APA: TCheckBox<br />
Left = 16<br />
Top = 16<br />
Width = 177<br />
Height = 31<br />
Caption = 'Load last APA'<br />
Checked = True<br />
State = cbChecked<br />
TabOrder = 0<br />
end<br />
object APA_Remove_redundancy: TCheckBox<br />
Left = 16<br />
Top = 87<br />
Width = 177<br />
Height = 31<br />
Caption = 'Remove Redundancy'<br />
TabOrder = 1<br />
end<br />
object APA_Add_max_hier: TCheckBox<br />
Left = 16<br />
Top = 122<br />
Width = 153<br />
Height = 31<br />
Caption = 'Add max hierarchy'<br />
Checked = True<br />
State = cbChecked<br />
TabOrder = 2<br />
end<br />
object APA_Save_on_termination: TCheckBox<br />
Left = 17<br />
Top = 51<br />
Width = 200<br />
Height = 31<br />
- 415 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Caption = 'Save APA on termination of program'<br />
Checked = True<br />
State = cbChecked<br />
TabOrder = 3<br />
end<br />
object APA_ShowScreenheuristic: TCheckBox<br />
Left = 16<br />
Top = 158<br />
Width = 265<br />
Height = 31<br />
Caption = 'Show process screen during heuristic execution'<br />
Checked = True<br />
State = cbChecked<br />
TabOrder = 4<br />
end<br />
object APA_Show_Link_on_Desktop: TCheckBox<br />
Left = 16<br />
Top = 192<br />
Width = 249<br />
Height = 17<br />
Caption = 'Show link on desktop'<br />
Checked = True<br />
State = cbChecked<br />
TabOrder = 5<br />
OnExit = APA_Show_Link_on_DesktopExit<br />
end<br />
end<br />
object APA_Path_Settings: TTabSheet<br />
Caption = 'Path Settings'<br />
ImageIndex = 1<br />
object Label1: TLabel<br />
Left = 16<br />
Top = 16<br />
Width = 49<br />
Height = 13<br />
Caption = 'Savepath:'<br />
end<br />
object APA_Save_Path: TDirectoryListBox<br />
Left = 16<br />
Top = 48<br />
Width = 417<br />
Height = 129<br />
ItemHeight = 16<br />
TabOrder = 0<br />
end<br />
end<br />
end<br />
end<br />
12.1.23 UNIT APA_OPTIONSUNIT.PAS<br />
unit APA_Optionsunit;<br />
interface<br />
uses<br />
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,<br />
Dialogs, StdCtrls, ExtCtrls, ComCtrls, DB, DBTables, FileCtrl;<br />
type<br />
TAPA_Options = class(TForm)<br />
Panel1: TPanel;<br />
Button1: TButton;<br />
PageControl1: TPageControl;<br />
APA_On_Start: TTabSheet;<br />
APA_Load_Last_APA: TCheckBox;<br />
APA_Remove_redundancy: TCheckBox;<br />
APA_Add_max_hier: TCheckBox;<br />
APA_Path_Settings: TTabSheet;<br />
Label1: TLabel;<br />
APA_Save_Path: TDirectoryListBox;<br />
APA_Save_on_termination: TCheckBox;<br />
- 416 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
APA_ShowScreenheuristic: TCheckBox;<br />
APA_Show_Link_on_Desktop: TCheckBox;<br />
procedure Button1Click(Sender: TObject);<br />
procedure APA_Show_Link_on_DesktopExit(Sender: TObject);<br />
private<br />
{ Private-Deklarationen }<br />
public<br />
{ Public-Deklarationen }<br />
end;<br />
var<br />
APA_Options: TAPA_Options;<br />
implementation<br />
uses APA_Applicationunit;<br />
{$R *.dfm}<br />
procedure TAPA_Options.Button1Click(Sender: TObject);<br />
begin<br />
Close;<br />
end;<br />
procedure TAPA_Options.APA_Show_Link_on_DesktopExit(Sender: TObject);<br />
var fStreamladen,fStreamspeichern:TFileStream;<br />
begin<br />
if APA_Options.APA_Show_Link_on_Desktop.Checked=true then begin<br />
if fileexists(APA_Application.shelldir.Path+'\APAWin.lnk')=false then begin<br />
try<br />
fStreamLaden:=TFileStream.Create('c:\APADIR\PROGRAM\APAWin.lnk',fmOpenRead);<br />
try<br />
fStreamSpeichern:=TFileStream.Create(APA_Application.shelldir.Path+'\APAWin.lnk',f<br />
mCreate);<br />
fStreamSpeichern.CopyFrom(fStreamLaden, fStreamLaden.Size);<br />
finally<br />
freeandnil(fStreamSpeichern);<br />
end;<br />
finally<br />
freeandnil(fStreamLaden);<br />
end;<br />
end else begin<br />
//Löschen<br />
if fileexists(APA_Application.shelldir.Path+'\APAWin.lnk')=true then begin<br />
try<br />
deletefile(APA_Application.shelldir.Path+'\APAWin.lnk');<br />
except<br />
showmessage('Can not remove link from Desktop');<br />
end;<br />
end;<br />
end;<br />
end;<br />
end;<br />
end.<br />
12.1.24 UNIT APA_PARAMETERUNIT.DFM<br />
object APA_Parameter: TAPA_Parameter<br />
Left = 280<br />
Top = 188<br />
BorderStyle = bsDialog<br />
Caption = 'APA Parameter'<br />
ClientHeight = 483<br />
ClientWidth = 399<br />
Color = clBtnFace<br />
Font.Charset = DEFAULT_CHARSET<br />
Font.Color = clWindowText<br />
- 417 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Font.Height = -11<br />
Font.Name = 'MS Sans Serif'<br />
Font.Style = []<br />
OldCreateOrder = False<br />
Position = poScreenCenter<br />
OnClose = FormClose<br />
OnCreate = FormCreate<br />
OnShow = FormShow<br />
PixelsPerInch = 96<br />
TextHeight = 13<br />
object Panel1: TPanel<br />
Left = 0<br />
Top = 442<br />
Width = 399<br />
Height = 41<br />
Align = alBottom<br />
TabOrder = 0<br />
object Button1: TButton<br />
Left = 134<br />
Top = 8<br />
Width = 75<br />
Height = 25<br />
Caption = 'Close'<br />
TabOrder = 0<br />
OnClick = Button1Click<br />
end<br />
end<br />
object APA_Parameter_Control: TPageControl<br />
Left = 0<br />
Top = 0<br />
Width = 399<br />
Height = 442<br />
ActivePage = APA_Active_heuristicsheet<br />
Align = alClient<br />
TabOrder = 1<br />
object APA_Active_heuristicsheet: TTabSheet<br />
Caption = 'Heuristic && Algorithms parameters'<br />
object GroupBox3: TGroupBox<br />
Left = 0<br />
Top = 0<br />
Width = 391<br />
Height = 161<br />
Align = alTop<br />
Caption = 'Thomas Achs heuristic parameters'<br />
TabOrder = 0<br />
object Label1: TLabel<br />
Left = 24<br />
Top = 24<br />
Width = 128<br />
Height = 13<br />
Caption = 'New Sets on each iteration'<br />
end<br />
object Label2: TLabel<br />
Left = 24<br />
Top = 72<br />
Width = 116<br />
Height = 13<br />
Caption = 'Count of Sets calculated'<br />
end<br />
object APA_Thomas_newsetsoneachiteration: TMaskEdit<br />
Left = 24<br />
Top = 40<br />
Width = 33<br />
Height = 21<br />
EditMask = '0##;0; '<br />
MaxLength = 3<br />
TabOrder = 0<br />
OnExit = APA_Thomas_newsetsoneachiterationExit<br />
end<br />
object APA_Thomas_countofsets: TMaskEdit<br />
Left = 24<br />
Top = 88<br />
Width = 39<br />
Height = 21<br />
- 418 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
EditMask = '0###;0; '<br />
MaxLength = 4<br />
TabOrder = 1<br />
OnExit = APA_Thomas_countofsetsExit<br />
end<br />
end<br />
end<br />
object Thomas_Achs_heuristic: TTabSheet<br />
Caption = 'Cost function parameters'<br />
object tomstorelabel: TLabel<br />
Left = 38<br />
Top = 318<br />
Width = 139<br />
Height = 13<br />
Caption = 'Storage importantance: 25 % '<br />
end<br />
object tomtimelabel: TLabel<br />
Left = 201<br />
Top = 318<br />
Width = 122<br />
Height = 13<br />
Alignment = taRightJustify<br />
Caption = 'Time importantance: 75 %'<br />
end<br />
object Label9: TLabel<br />
Left = 144<br />
Top = 264<br />
Width = 81<br />
Height = 20<br />
Caption = 'Importance'<br />
Font.Charset = DEFAULT_CHARSET<br />
Font.Color = clWindowText<br />
Font.Height = -16<br />
Font.Name = 'MS Sans Serif'<br />
Font.Style = []<br />
ParentFont = False<br />
end<br />
object tommatcosts: TLabel<br />
Left = 42<br />
Top = 396<br />
Width = 127<br />
Height = 13<br />
Caption = 'Materialisation costs: 25 % '<br />
end<br />
object tomquerycosts: TLabel<br />
Left = 242<br />
Top = 396<br />
Width = 85<br />
Height = 13<br />
Alignment = taRightJustify<br />
Caption = 'Query costs: 75 %'<br />
end<br />
object Label10: TLabel<br />
Left = 159<br />
Top = 342<br />
Width = 50<br />
Height = 20<br />
Caption = 'Weight'<br />
Font.Charset = DEFAULT_CHARSET<br />
Font.Color = clWindowText<br />
Font.Height = -16<br />
Font.Name = 'MS Sans Serif'<br />
Font.Style = []<br />
ParentFont = False<br />
end<br />
object APA_Thomas_Importance: TTrackBar<br />
Left = 41<br />
Top = 286<br />
Width = 281<br />
Height = 25<br />
Hint = 'Select the weight of '<br />
Max = 100<br />
ParentShowHint = False<br />
Frequency = 5<br />
- 419 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Position = 10<br />
ShowHint = True<br />
TabOrder = 0<br />
TickMarks = tmBoth<br />
OnChange = APA_Thomas_ImportanceChange<br />
end<br />
object APA_Thomas_Query_Importance: TTrackBar<br />
Left = 44<br />
Top = 366<br />
Width = 281<br />
Height = 25<br />
Hint = 'Select the weight of '<br />
Max = 100<br />
ParentShowHint = False<br />
Frequency = 5<br />
Position = 10<br />
ShowHint = True<br />
TabOrder = 1<br />
TickMarks = tmBoth<br />
OnChange = APA_Thomas_Query_ImportanceChange<br />
end<br />
object GroupBox4: TGroupBox<br />
Left = 0<br />
Top = 161<br />
Width = 391<br />
Height = 88<br />
Align = alTop<br />
Caption = 'Sizeoriented Parameters'<br />
TabOrder = 2<br />
object Label13: TLabel<br />
Left = 52<br />
Top = 19<br />
Width = 158<br />
Height = 26<br />
Alignment = taRightJustify<br />
Caption = 'Average size in bytes per tupel in BFT in space units:'<br />
WordWrap = True<br />
end<br />
object Label14: TLabel<br />
Left = 50<br />
Top = 47<br />
Width = 160<br />
Height = 26<br />
Alignment = taRightJustify<br />
Caption =<br />
'Max available storage space for Materialized Cubes in space unit' +<br />
's:'<br />
WordWrap = True<br />
end<br />
object APA_Thomas_avsizeoftupel: TMaskEdit<br />
Left = 219<br />
Top = 22<br />
Width = 144<br />
Height = 21<br />
EditMask = '0###########;0; '<br />
MaxLength = 12<br />
TabOrder = 0<br />
OnChange = APA_Thomas_timemaxChange<br />
OnExit = APA_Thomas_avsizeoftupelExit<br />
end<br />
object APA_Thomas_spacemax: TMaskEdit<br />
Left = 219<br />
Top = 50<br />
Width = 144<br />
Height = 21<br />
EditMask = '0#####################;0; '<br />
MaxLength = 22<br />
TabOrder = 1<br />
OnChange = APA_Thomas_timemaxChange<br />
OnExit = APA_Thomas_spacemaxExit<br />
end<br />
end<br />
object GroupBox5: TGroupBox<br />
Left = 0<br />
- 420 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Top = 0<br />
Width = 391<br />
Height = 161<br />
Align = alTop<br />
Caption = 'Timeoriented Parameters'<br />
TabOrder = 3<br />
object Label12: TLabel<br />
Left = 14<br />
Top = 49<br />
Width = 196<br />
Height = 13<br />
Alignment = taRightJustify<br />
Caption = 'Average time for IO per tupel in time units:'<br />
end<br />
object Label15: TLabel<br />
Left = 50<br />
Top = 94<br />
Width = 160<br />
Height = 26<br />
Alignment = taRightJustify<br />
Caption = 'Max available time in time units to Build Materialized Cubes :'<br />
WordWrap = True<br />
end<br />
object Label16: TLabel<br />
Left = 43<br />
Top = 14<br />
Width = 167<br />
Height = 26<br />
Alignment = taRightJustify<br />
Caption =<br />
'Average time to store a tupel (Build materialized views) in time' +<br />
' units:'<br />
WordWrap = True<br />
end<br />
object Label3: TLabel<br />
Left = 57<br />
Top = 124<br />
Width = 157<br />
Height = 26<br />
Alignment = taRightJustify<br />
Caption = 'Maximal average time to query in time units:'<br />
WordWrap = True<br />
end<br />
object Label4: TLabel<br />
Left = 7<br />
Top = 76<br />
Width = 204<br />
Height = 13<br />
Alignment = taRightJustify<br />
Caption = 'Average time of CPU per tupel in time units:'<br />
end<br />
object APA_Thomas_timestore: TMaskEdit<br />
Left = 218<br />
Top = 17<br />
Width = 158<br />
Height = 21<br />
TabOrder = 0<br />
Text = '2'<br />
OnChange = APA_Thomas_timemaxChange<br />
OnExit = APA_Thomas_timestoreExit<br />
end<br />
object APA_Thomas_timeio: TMaskEdit<br />
Left = 218<br />
Top = 45<br />
Width = 158<br />
Height = 21<br />
TabOrder = 1<br />
Text = '2'<br />
OnChange = APA_Thomas_timemaxChange<br />
OnExit = APA_Thomas_timeioExit<br />
end<br />
object APA_Thomas_timemax: TMaskEdit<br />
Left = 218<br />
Top = 100<br />
- 421 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Width = 155<br />
Height = 21<br />
EditMask = '0###########;0; '<br />
MaxLength = 12<br />
TabOrder = 3<br />
OnChange = APA_Thomas_timemaxChange<br />
OnExit = APA_Thomas_timemaxExit<br />
end<br />
object APA_Thomas_querytimemax: TMaskEdit<br />
Left = 218<br />
Top = 127<br />
Width = 157<br />
Height = 21<br />
TabOrder = 4<br />
Text = '20'<br />
OnChange = APA_Thomas_timemaxChange<br />
OnExit = APA_Thomas_querytimemaxExit<br />
end<br />
object APA_Thomas_timecpu: TMaskEdit<br />
Left = 218<br />
Top = 73<br />
Width = 151<br />
Height = 21<br />
TabOrder = 2<br />
OnChange = APA_Thomas_timemaxChange<br />
OnExit = APA_Thomas_timecpuExit<br />
end<br />
end<br />
end<br />
object Values_of_Cubes: TTabSheet<br />
Caption = 'Degrees of requirements'<br />
object Panel2: TPanel<br />
Left = 0<br />
Top = 0<br />
Width = 391<br />
Height = 137<br />
Align = alTop<br />
TabOrder = 0<br />
object Label19: TLabel<br />
Left = 8<br />
Top = 8<br />
Width = 101<br />
Height = 13<br />
Caption = 'Description of degree'<br />
end<br />
object Label21: TLabel<br />
Left = 8<br />
Top = 48<br />
Width = 77<br />
Height = 13<br />
Caption = 'Count of queries'<br />
end<br />
object APA_Description_of_degree: TEdit<br />
Left = 8<br />
Top = 24<br />
Width = 201<br />
Height = 21<br />
Enabled = False<br />
TabOrder = 0<br />
end<br />
object Panel3: TPanel<br />
Left = 1<br />
Top = 96<br />
Width = 389<br />
Height = 40<br />
Align = alBottom<br />
TabOrder = 2<br />
object APA_Degree_Insert: TButton<br />
Left = 21<br />
Top = 8<br />
Width = 55<br />
Height = 25<br />
Caption = 'Insert'<br />
TabOrder = 0<br />
- 422 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
OnClick = APA_Degree_InsertClick<br />
end<br />
object APA_Degree_Edit: TButton<br />
Left = 85<br />
Top = 8<br />
Width = 55<br />
Height = 25<br />
Caption = 'Edit'<br />
TabOrder = 1<br />
OnClick = APA_Degree_EditClick<br />
end<br />
object APA_Degree_Save: TButton<br />
Left = 149<br />
Top = 8<br />
Width = 55<br />
Height = 25<br />
Caption = 'Save'<br />
Enabled = False<br />
TabOrder = 2<br />
OnClick = APA_Degree_SaveClick<br />
end<br />
object APA_Degree_Delete: TButton<br />
Left = 213<br />
Top = 8<br />
Width = 55<br />
Height = 25<br />
Caption = 'Delete'<br />
TabOrder = 3<br />
OnClick = APA_Degree_DeleteClick<br />
end<br />
object APA_Degree_Abort: TButton<br />
Left = 277<br />
Top = 7<br />
Width = 55<br />
Height = 25<br />
Caption = 'Abort'<br />
Enabled = False<br />
TabOrder = 4<br />
OnClick = APA_Degree_AbortClick<br />
end<br />
end<br />
object APA_Count_of_Queries: TMaskEdit<br />
Left = 9<br />
Top = 64<br />
Width = 136<br />
Height = 21<br />
Enabled = False<br />
EditMask = '0###############;0; '<br />
MaxLength = 16<br />
TabOrder = 1<br />
OnChange = APA_Thomas_timemaxChange<br />
OnExit = APA_Count_of_QueriesExit<br />
end<br />
end<br />
object Panel4: TPanel<br />
Left = 0<br />
Top = 137<br />
Width = 42<br />
Height = 277<br />
Align = alLeft<br />
TabOrder = 1<br />
object APA_Degree_up: TBitBtn<br />
Left = 5<br />
Top = 4<br />
Width = 28<br />
Height = 25<br />
Caption = 'UP'<br />
TabOrder = 0<br />
OnClick = APA_Degree_upClick<br />
Layout = blGlyphTop<br />
end<br />
object APA_Degree_Down: TBitBtn<br />
Left = 0<br />
Top = 36<br />
- 423 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Width = 39<br />
Height = 25<br />
Caption = 'DOWN'<br />
TabOrder = 1<br />
OnClick = APA_Degree_DownClick<br />
Layout = blGlyphTop<br />
end<br />
end<br />
object GroupBox1: TGroupBox<br />
Left = 258<br />
Top = 137<br />
Width = 133<br />
Height = 277<br />
Align = alRight<br />
Caption = 'Count of queries'<br />
TabOrder = 2<br />
object APA_Degreecounts: TListBox<br />
Left = 2<br />
Top = 15<br />
Width = 129<br />
Height = 260<br />
Align = alClient<br />
ItemHeight = 13<br />
Items.Strings = (<br />
'10000'<br />
'1000'<br />
'1')<br />
TabOrder = 0<br />
OnClick = APA_DegreecountsClick<br />
end<br />
end<br />
object GroupBox2: TGroupBox<br />
Left = 42<br />
Top = 137<br />
Width = 216<br />
Height = 277<br />
Align = alClient<br />
Caption = 'Description of degree'<br />
TabOrder = 3<br />
object APA_Degrees: TListBox<br />
Left = 2<br />
Top = 15<br />
Width = 212<br />
Height = 260<br />
Align = alClient<br />
ItemHeight = 13<br />
Items.Strings = (<br />
'High Importance'<br />
'Normal Importance'<br />
'Unimportant')<br />
TabOrder = 0<br />
OnClick = APA_DegreesClick<br />
end<br />
end<br />
end<br />
object APA_Colors_of_Degrees: TTabSheet<br />
Caption = 'Colors of Requirements'<br />
ImageIndex = 4<br />
object Panel5: TPanel<br />
Left = 0<br />
Top = 0<br />
Width = 391<br />
Height = 41<br />
Align = alTop<br />
TabOrder = 0<br />
object APA_Changecolorbutton: TButton<br />
Left = 8<br />
Top = 8<br />
Width = 121<br />
Height = 25<br />
Caption = 'Change color'<br />
TabOrder = 0<br />
OnClick = APA_ChangecolorbuttonClick<br />
end<br />
- 424 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
end<br />
object Colorsgrid: TDrawGrid<br />
Left = 0<br />
Top = 41<br />
Width = 391<br />
Height = 373<br />
Align = alClient<br />
ColCount = 1<br />
DefaultColWidth = 300<br />
FixedCols = 0<br />
RowCount = 15<br />
FixedRows = 0<br />
Options = [goFixedVertLine, goFixedHorzLine, goVertLine, goHorzLine,<br />
goRangeSelect, goRowSelect]<br />
TabOrder = 1<br />
OnDrawCell = ColorsgridDrawCell<br />
RowHeights = (<br />
24<br />
24<br />
24<br />
24<br />
24<br />
24<br />
24<br />
24<br />
24<br />
24<br />
24<br />
24<br />
24<br />
24<br />
24)<br />
end<br />
end<br />
end<br />
object ColorDialog: TColorDialog<br />
Left = 308<br />
Top = 280<br />
end<br />
end<br />
12.1.25 UNIT APA_PARAMETERUNIT.PAS<br />
unit APA_Parameterunit;<br />
interface<br />
uses<br />
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,<br />
Dialogs, ComCtrls, StdCtrls, ExtCtrls, Buttons, Grids, Mask;<br />
type<br />
TAPA_Parameter = class(TForm)<br />
Panel1: TPanel;<br />
Button1: TButton;<br />
APA_Parameter_Control: TPageControl;<br />
Values_of_Cubes: TTabSheet;<br />
Panel2: TPanel;<br />
Label19: TLabel;<br />
APA_Description_of_degree: TEdit;<br />
Panel3: TPanel;<br />
APA_Degree_Insert: TButton;<br />
APA_Degree_Edit: TButton;<br />
APA_Degree_Save: TButton;<br />
APA_Degree_Delete: TButton;<br />
Label21: TLabel;<br />
Panel4: TPanel;<br />
APA_Degree_up: TBitBtn;<br />
APA_Degree_Down: TBitBtn;<br />
APA_Active_heuristicsheet: TTabSheet;<br />
Thomas_Achs_heuristic: TTabSheet;<br />
- 425 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
GroupBox1: TGroupBox;<br />
APA_Degreecounts: TListBox;<br />
GroupBox2: TGroupBox;<br />
APA_Degrees: TListBox;<br />
APA_Degree_Abort: TButton;<br />
APA_Colors_of_Degrees: TTabSheet;<br />
ColorDialog: TColorDialog;<br />
Panel5: TPanel;<br />
APA_Changecolorbutton: TButton;<br />
Colorsgrid: TDrawGrid;<br />
tomstorelabel: TLabel;<br />
tomtimelabel: TLabel;<br />
Label9: TLabel;<br />
APA_Thomas_Importance: TTrackBar;<br />
tommatcosts: TLabel;<br />
tomquerycosts: TLabel;<br />
Label10: TLabel;<br />
APA_Thomas_Query_Importance: TTrackBar;<br />
GroupBox3: TGroupBox;<br />
APA_Thomas_newsetsoneachiteration: TMaskEdit;<br />
Label1: TLabel;<br />
APA_Thomas_countofsets: TMaskEdit;<br />
Label2: TLabel;<br />
APA_Count_of_Queries: TMaskEdit;<br />
GroupBox4: TGroupBox;<br />
Label13: TLabel;<br />
Label14: TLabel;<br />
APA_Thomas_avsizeoftupel: TMaskEdit;<br />
APA_Thomas_spacemax: TMaskEdit;<br />
GroupBox5: TGroupBox;<br />
Label12: TLabel;<br />
Label15: TLabel;<br />
Label16: TLabel;<br />
Label3: TLabel;<br />
APA_Thomas_timestore: TMaskEdit;<br />
APA_Thomas_timeio: TMaskEdit;<br />
APA_Thomas_timemax: TMaskEdit;<br />
APA_Thomas_querytimemax: TMaskEdit;<br />
Label4: TLabel;<br />
APA_Thomas_timecpu: TMaskEdit;<br />
procedure Button1Click(Sender: TObject);<br />
procedure FormShow(Sender: TObject);<br />
procedure FormCreate(Sender: TObject);<br />
procedure APA_Degree_InsertClick(Sender: TObject);<br />
procedure APA_DegreesClick(Sender: TObject);<br />
procedure APA_DegreecountsClick(Sender: TObject);<br />
procedure APA_Degree_SaveClick(Sender: TObject);<br />
procedure APA_Degree_EditClick(Sender: TObject);<br />
procedure FormClose(Sender: TObject; var Action: TCloseAction);<br />
procedure APA_Degree_AbortClick(Sender: TObject);<br />
procedure APA_Degree_DeleteClick(Sender: TObject);<br />
procedure APA_Degree_upClick(Sender: TObject);<br />
procedure APA_Degree_DownClick(Sender: TObject);<br />
procedure ColorBox1Exit(Sender: TObject);<br />
procedure ColorsgridDrawCell(Sender: TObject; ACol, ARow: Integer;<br />
Rect: TRect; State: TGridDrawState);<br />
procedure APA_ChangecolorbuttonClick(Sender: TObject);<br />
procedure Colorsgrid2DrawCell(Sender: TObject; ACol, ARow: Integer;<br />
Rect: TRect; State: TGridDrawState);<br />
procedure APA_Thomas_ImportanceChange(Sender: TObject);<br />
procedure APA_Thomas_Query_ImportanceChange(Sender: TObject);<br />
procedure APA_Thomas_timemaxChange(Sender: TObject);<br />
procedure APA_Thomas_newsetsoneachiterationExit(Sender: TObject);<br />
procedure APA_Thomas_countofsetsExit(Sender: TObject);<br />
procedure APA_Thomas_timestoreExit(Sender: TObject);<br />
procedure APA_Thomas_timeioExit(Sender: TObject);<br />
procedure APA_Thomas_timecpuExit(Sender: TObject);<br />
procedure APA_Thomas_timemaxExit(Sender: TObject);<br />
procedure APA_Thomas_querytimemaxExit(Sender: TObject);<br />
procedure APA_Thomas_avsizeoftupelExit(Sender: TObject);<br />
procedure APA_Thomas_spacemaxExit(Sender: TObject);<br />
procedure APA_Count_of_QueriesExit(Sender: TObject);<br />
private<br />
{ Private-Deklarationen }<br />
- 426 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
public<br />
{ Public-Deklarationen }<br />
end;<br />
var<br />
APA_Parameter: TAPA_Parameter;<br />
DegreeColors:array[0..14] of TColor;<br />
Othercolors:array[0..14] of TColor;<br />
implementation<br />
uses APA_Applicationunit, APA_Gridunit, APA_Selectionunit;<br />
{$R *.dfm}<br />
var degreeedit:longint=-2;<br />
procedure TAPA_Parameter.Button1Click(Sender: TObject);<br />
begin<br />
Close;<br />
end;<br />
procedure TAPA_Parameter.FormShow(Sender: TObject);<br />
begin<br />
APA_Thomas_ImportanceChange(self);<br />
APA_Thomas_Query_ImportanceChange(self);<br />
end;<br />
procedure TAPA_Parameter.FormCreate(Sender: TObject);<br />
begin<br />
APA_Parameter_Control.ActivePageIndex:=0;<br />
APA_Thomas_Importance.Position:=75;<br />
APA_Thomas_Query_Importance.Position:=75;<br />
//Standardfarben für Requirements festlegen<br />
DegreeColors[0]:=clBlue;<br />
DegreeColors[1]:=clMaroon;<br />
DegreeColors[2]:=clGreen;<br />
DegreeColors[3]:=clOlive;<br />
DegreeColors[4]:=clNavy;<br />
DegreeColors[5]:=clPurple;<br />
DegreeColors[6]:=clTeal;<br />
DegreeColors[7]:=clGray;<br />
DegreeColors[8]:=clRed;<br />
DegreeColors[9]:=clFuchsia;<br />
DegreeColors[10]:=clAqua;<br />
DegreeColors[11]:=clLtGray;<br />
DegreeColors[12]:=clCream;<br />
DegreeColors[13]:=clSkyBlue;<br />
DegreeColors[14]:=clMoneyGreen;<br />
OtherColors[0]:=clYellow; //Farbe für Rednundanzfrei<br />
OtherColors[1]:=clRed; //Farbe für materalisiert<br />
OtherColors[2]:=clBlack; //Farbe für Derivate<br />
end;<br />
procedure TAPA_Parameter.APA_Degree_InsertClick(Sender: TObject);<br />
begin<br />
if APA_Degrees.Items.Count
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
mustsave:=true;<br />
end else showmessage('Maxium Count of Entrys of 15 reached');<br />
end;<br />
procedure TAPA_Parameter.APA_DegreesClick(Sender: TObject);<br />
begin<br />
APA_Degreecounts.ItemIndex:=APA_Degrees.ItemIndex;<br />
end;<br />
procedure TAPA_Parameter.APA_DegreecountsClick(Sender: TObject);<br />
begin<br />
APA_Degrees.ItemIndex:=APA_Degreecounts.ItemIndex;<br />
end;<br />
procedure TAPA_Parameter.APA_Degree_SaveClick(Sender: TObject);<br />
begin<br />
mustsave:=true;<br />
APA_Description_of_degree.Enabled:=false;<br />
APA_Count_of_Queries.Enabled:=false;<br />
APA_Degree_Insert.Enabled:=true;<br />
APA_Degree_Edit.Enabled:=true;<br />
APA_Degree_Save.Enabled:=false;<br />
APA_Degree_Delete.Enabled:=true;<br />
APA_Degree_Abort.Enabled:=false;<br />
if APA_Degree_Edit.tag=0 then begin<br />
APA_Degrees.Items.Add(APA_Description_of_degree.Text);<br />
APA_Degreecounts.Items.Add(APA_Count_of_Queries.Text);<br />
end else begin<br />
APA_Degrees.Items[APA_Degrees.itemindex]:=APA_Description_of_degree.Text;<br />
APA_Degreecounts.Items[APA_Degreecounts.ItemIndex]:=APA_Count_of_Queries.Text;<br />
end;<br />
APA_Degree_Edit.Tag:=0;<br />
end;<br />
procedure TAPA_Parameter.APA_Degree_EditClick(Sender: TObject);<br />
begin<br />
if APA_Degrees.ItemIndex-1 then begin<br />
APA_Description_of_degree.Enabled:=true;<br />
APA_Count_of_Queries.Enabled:=true;<br />
APA_Degree_Insert.Enabled:=false;<br />
APA_Degree_Edit.Enabled:=false;<br />
APA_Degree_Save.Enabled:=true;<br />
APA_Degree_Delete.Enabled:=false;<br />
APA_Degree_Abort.Enabled:=true;<br />
APA_Description_of_degree.Text:= APA_Degrees.Items[APA_Degrees.itemindex];<br />
APA_Count_of_Queries.Text:= APA_Degreecounts.Items[APA_Degreecounts.itemindex];<br />
APA_Description_of_degree.SetFocus;<br />
APA_Degree_Edit.Tag:=1;//Edit Mode setzen<br />
mustsave:=true;<br />
end else showmessage('No Entry selected');<br />
end;<br />
procedure TAPA_Parameter.FormClose(Sender: TObject;<br />
var Action: TCloseAction);<br />
begin<br />
if APA_Degree_Edit.Tag=1 then begin<br />
if messagedlg('Do you want to save your changes?',mtconfirmation,[mbyes,mbno],0)=mryes<br />
then APA_Degree_Save.Click else APA_Degree_Abort.Click;<br />
end;<br />
end;<br />
procedure TAPA_Parameter.APA_Degree_AbortClick(Sender: TObject);<br />
begin<br />
mustsave:=true;<br />
APA_Description_of_degree.Enabled:=false;<br />
APA_Count_of_Queries.Enabled:=false;<br />
APA_Degree_Insert.Enabled:=true;<br />
- 428 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
APA_Degree_Edit.Enabled:=true;<br />
APA_Degree_Save.Enabled:=false;<br />
APA_Degree_Delete.Enabled:=true;<br />
APA_Degree_Abort.Enabled:=false;<br />
APA_Degree_Edit.Tag:=0;<br />
end;<br />
procedure TAPA_Parameter.APA_Degree_DeleteClick(Sender: TObject);<br />
var ok:boolean;<br />
var aktzeile,aktspalte:longint;<br />
begin<br />
if APA_Degrees.ItemIndex-1 then begin<br />
ok:=true;<br />
for aktspalte:=0 to anzspalten-1 do begin<br />
for aktzeile:=0 to anzzeilen-1 do begin<br />
if APA[aktspalte,aktzeile].interessant=true then begin<br />
if APA[aktspalte,aktzeile].gewichtlevel=APA_Degrees.ItemIndex then begin<br />
ok:=false;<br />
end;<br />
end;<br />
end;<br />
end;<br />
if ok=false then showmessage('Degree is used in APA. Could not delete degree!');<br />
if ok=true then begin<br />
for aktzeile:= 0 to APA_Selection_Screen.Listeint.items.count-1 do begin<br />
if copy(APA_Selection_Screen.Listeint.items[aktzeile],1,3)='Req' then begin<br />
if<br />
APA_Degrees.ItemIndex=strtoint(copy(APA_Selection_Screen.Listeint.items[aktzeile],<br />
5,100)) then begin<br />
ok:=false;<br />
end;<br />
end;<br />
end;<br />
if ok=false then showmessage('Degree is used in Selection Screen. Could not delete<br />
degree!');<br />
end;<br />
if ok=true then begin<br />
APA_Degreecounts.Items.Delete(APA_Degrees.ItemIndex);<br />
APA_Degrees.Items.Delete(APA_Degrees.ItemIndex);<br />
mustsave:=true;<br />
end;<br />
end else showmessage('No Entry selected');<br />
end;<br />
procedure TAPA_Parameter.APA_Degree_upClick(Sender: TObject);<br />
var ok:boolean;<br />
var aktspalte,aktzeile:longint;<br />
begin<br />
if (APA_Degrees.ItemIndex-1) then begin<br />
if (APA_Degrees.ItemIndex0) then begin<br />
ok:=true;<br />
for aktspalte:=0 to anzspalten-1 do begin<br />
for aktzeile:=0 to anzzeilen-1 do begin<br />
if APA[aktspalte,aktzeile].interessant=true then begin<br />
if (APA[aktspalte,aktzeile].gewichtlevel=APA_Degrees.ItemIndex)or<br />
(APA[aktspalte,aktzeile].gewichtlevel=APA_Degrees.ItemIndex-1) then begin<br />
ok:=false;<br />
end;<br />
end;<br />
- 429 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
end;<br />
end;<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if ok=false then showmessage('Degree or upper degree is used in APA. Could not move<br />
degree!');<br />
if ok=true then begin<br />
for aktzeile:= 0 to APA_Selection_Screen.Listeint.items.count-1 do begin<br />
if copy(APA_Selection_Screen.Listeint.items[aktzeile],1,3)='Req' then begin<br />
if<br />
(APA_Degrees.ItemIndex=strtoint(copy(APA_Selection_Screen.Listeint.items[aktzeile]<br />
,5,100))) or<br />
(APA_Degrees.ItemIndex-<br />
1=strtoint(copy(APA_Selection_Screen.Listeint.items[aktzeile],5,100)))then begin<br />
ok:=false;<br />
end;<br />
end;<br />
end;<br />
if ok=false then showmessage('Degree or upper degree is used in Selection Screen. Could<br />
not move degree!');<br />
end;<br />
if ok=true then begin<br />
end;<br />
APA_Degrees.Items.Move(APA_Degrees.ItemIndex,APA_Degrees.ItemIndex-1);<br />
mustsave:=true;<br />
end else showmessage('Top Entry selected');<br />
end else showmessage('No Entry selected');<br />
end;<br />
procedure TAPA_Parameter.APA_Degree_DownClick(Sender: TObject);<br />
var ok:boolean;<br />
var aktspalte,aktzeile:longint;<br />
begin<br />
if (APA_Degrees.ItemIndex-1) then begin<br />
if (APA_Degrees.ItemIndexAPA_Degrees.Items.Count-1) then begin<br />
ok:=true;<br />
for aktspalte:=0 to anzspalten-1 do begin<br />
for aktzeile:=0 to anzzeilen-1 do begin<br />
if APA[aktspalte,aktzeile].interessant=true then begin<br />
if (APA[aktspalte,aktzeile].gewichtlevel=APA_Degrees.ItemIndex)or<br />
(APA[aktspalte,aktzeile].gewichtlevel=APA_Degrees.ItemIndex+1) then begin<br />
ok:=false;<br />
end;<br />
end;<br />
end;<br />
end;<br />
if ok=false then showmessage('Degree oder lower degree is used in APA. Could not move<br />
degree!');<br />
if ok=true then begin<br />
for aktzeile:= 0 to APA_Selection_Screen.Listeint.items.count-1 do begin<br />
if copy(APA_Selection_Screen.Listeint.items[aktzeile],1,3)='Req' then begin<br />
if<br />
(APA_Degrees.ItemIndex=strtoint(copy(APA_Selection_Screen.Listeint.items[aktzeile]<br />
,5,100)))or<br />
(APA_Degrees.ItemIndex+1=strtoint(copy(APA_Selection_Screen.Listeint.items[aktzeil<br />
e],5,100))) then begin<br />
ok:=false;<br />
end;<br />
end;<br />
end;<br />
if ok=false then showmessage('Degree or lower degree is used in Selection Screen. Could<br />
not move degree!');<br />
end;<br />
if ok=true then begin<br />
- 430 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
mustsave:=true;<br />
APA_Degrees.Items.Move(APA_Degrees.ItemIndex,APA_Degrees.ItemIndex+1);<br />
end;<br />
end else showmessage('Last Entry selected');<br />
end else showmessage('No Entry selected');<br />
end;<br />
procedure TAPA_Parameter.ColorBox1Exit(Sender: TObject);<br />
begin<br />
Colordialog.Execute;<br />
end;<br />
procedure TAPA_Parameter.ColorsgridDrawCell(Sender: TObject; ACol,<br />
ARow: Integer; Rect: TRect; State: TGridDrawState);<br />
begin<br />
Colorsgrid.Canvas.Brush.Color:=DegreeColors[Arow];<br />
Colorsgrid.Canvas.FillRect(Rect);<br />
if Arow
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
procedure TAPA_Parameter.APA_Thomas_Query_ImportanceChange(<br />
Sender: TObject);<br />
begin<br />
mustsave:=true;<br />
tommatcosts.Caption:='Materialisation costs: '+<br />
inttostr(100-APA_Thomas_Query_Importance.Position)+' %';<br />
tomquerycosts.Caption:='Query costs: '+<br />
inttostr(APA_Thomas_Query_Importance.Position)+' %';<br />
end;<br />
procedure TAPA_Parameter.APA_Thomas_timemaxChange(Sender: TObject);<br />
begin<br />
mustsave:=true;<br />
end;<br />
procedure TAPA_Parameter.APA_Thomas_newsetsoneachiterationExit(<br />
Sender: TObject);<br />
begin<br />
APA_Thomas_newsetsoneachiteration.Text:=<br />
trim (APA_Thomas_newsetsoneachiteration.Text);<br />
try<br />
strtoint(APA_Thomas_newsetsoneachiteration.Text);<br />
except<br />
APA_Thomas_newsetsoneachiteration.Text:='2';<br />
end;<br />
end;<br />
procedure TAPA_Parameter.APA_Thomas_countofsetsExit(Sender: TObject);<br />
begin<br />
APA_Thomas_countofsets.Text:=<br />
trim(APA_Thomas_countofsets.Text);<br />
try<br />
strtoint(APA_Thomas_countofsets.Text);<br />
except<br />
APA_Thomas_countofsets.Text:='10';<br />
end;<br />
end;<br />
procedure TAPA_Parameter.APA_Thomas_timestoreExit(Sender: TObject);<br />
begin<br />
APA_Thomas_timestore.Text:=<br />
trim(APA_Thomas_timestore.Text);<br />
try<br />
strtofloat(APA_Thomas_timestore.Text);<br />
except<br />
APA_Thomas_timestore.Text:='2';<br />
end;<br />
end;<br />
procedure TAPA_Parameter.APA_Thomas_timeioExit(Sender: TObject);<br />
begin<br />
APA_Thomas_timeio.Text:=<br />
trim(APA_Thomas_timeio.Text);<br />
try<br />
strtofloat(APA_Thomas_timeio.Text);<br />
except<br />
APA_Thomas_timeio.Text:='2';<br />
end;<br />
end;<br />
procedure TAPA_Parameter.APA_Thomas_timecpuExit(Sender: TObject);<br />
begin<br />
APA_Thomas_timecpu.Text:=<br />
- 432 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
trim(APA_Thomas_timecpu.Text);<br />
try<br />
strtofloat(APA_Thomas_timecpu.Text);<br />
except<br />
APA_Thomas_timecpu.Text:='0,002';<br />
end;<br />
end;<br />
procedure TAPA_Parameter.APA_Thomas_timemaxExit(Sender: TObject);<br />
begin<br />
APA_Thomas_timemax.Text:=trim(APA_Thomas_timemax.Text);<br />
try<br />
strtofloat(APA_Thomas_timemax.Text);<br />
except<br />
APA_Thomas_timemax.Text:='200000';<br />
end;<br />
end;<br />
procedure TAPA_Parameter.APA_Thomas_querytimemaxExit(Sender: TObject);<br />
begin<br />
APA_Thomas_querytimemax.Text:=trim(APA_Thomas_querytimemax.Text);<br />
try<br />
strtofloat(APA_Thomas_querytimemax.Text);<br />
except<br />
APA_Thomas_querytimemax.Text:='20';<br />
end;<br />
end;<br />
procedure TAPA_Parameter.APA_Thomas_avsizeoftupelExit(Sender: TObject);<br />
begin<br />
APA_Thomas_avsizeoftupel.Text:=trim(APA_Thomas_avsizeoftupel.Text);<br />
try<br />
strtofloat(APA_Thomas_avsizeoftupel.Text);<br />
except<br />
APA_Thomas_avsizeoftupel.Text:='32';<br />
end;<br />
end;<br />
procedure TAPA_Parameter.APA_Thomas_spacemaxExit(Sender: TObject);<br />
begin<br />
APA_Thomas_spacemax.Text:=trim(APA_Thomas_spacemax.Text);<br />
try<br />
strtofloat(APA_Thomas_spacemax.Text);<br />
except<br />
APA_Thomas_spacemax.Text:='1000000';<br />
end;<br />
end;<br />
procedure TAPA_Parameter.APA_Count_of_QueriesExit(Sender: TObject);<br />
begin<br />
APA_Count_of_Queries.Text:=trim(APA_Count_of_Queries.text);<br />
try<br />
strtoint(APA_Count_of_Queries.Text);<br />
except<br />
APA_Count_of_Queries.Text:='1';<br />
end;<br />
end;<br />
end.<br />
- 433 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
12.1.26 UNIT APA_PROCESSUNIT.DFM<br />
object APA_Show_Process: TAPA_Show_Process<br />
Left = 266<br />
Top = 233<br />
BorderStyle = bsDialog<br />
Caption = 'Show Process'<br />
ClientHeight = 278<br />
ClientWidth = 322<br />
Color = clBtnFace<br />
Font.Charset = DEFAULT_CHARSET<br />
Font.Color = clWindowText<br />
Font.Height = -11<br />
Font.Name = 'MS Sans Serif'<br />
Font.Style = []<br />
FormStyle = fsStayOnTop<br />
OldCreateOrder = False<br />
Position = poScreenCenter<br />
OnClose = FormClose<br />
OnShow = FormShow<br />
PixelsPerInch = 96<br />
TextHeight = 13<br />
object Panel1: TPanel<br />
Left = 0<br />
Top = 237<br />
Width = 322<br />
Height = 41<br />
Align = alBottom<br />
TabOrder = 0<br />
object ButtonCancel: TButton<br />
Left = 36<br />
Top = 8<br />
Width = 75<br />
Height = 25<br />
Caption = 'Abort'<br />
TabOrder = 0<br />
OnClick = ButtonCancelClick<br />
end<br />
object ButtonPause: TButton<br />
Left = 184<br />
Top = 8<br />
Width = 75<br />
Height = 25<br />
Caption = 'Pause'<br />
TabOrder = 1<br />
OnClick = ButtonPauseClick<br />
end<br />
end<br />
object GroupBox1: TGroupBox<br />
Left = 0<br />
Top = 0<br />
Width = 322<br />
Height = 237<br />
Align = alClient<br />
Caption = 'Protocoll'<br />
TabOrder = 1<br />
OnDblClick = GroupBox1DblClick<br />
object APA_Protocoll: TListBox<br />
Left = 2<br />
Top = 15<br />
Width = 318<br />
Height = 220<br />
Align = alClient<br />
ItemHeight = 13<br />
TabOrder = 0<br />
end<br />
end<br />
object Ausschalten: TTimer<br />
Enabled = False<br />
Interval = 5000<br />
OnTimer = AusschaltenTimer<br />
Left = 128<br />
Top = 112<br />
- 434 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
end<br />
object secretMenu1: TPopupMenu<br />
Left = 176<br />
Top = 64<br />
object up1: TMenuItem<br />
Caption = 'up'<br />
OnClick = up1Click<br />
end<br />
object down1: TMenuItem<br />
Caption = 'down'<br />
OnClick = down1Click<br />
end<br />
object ShowProtokoll1: TMenuItem<br />
Caption = 'Show Protokoll'<br />
OnClick = ShowProtokoll1Click<br />
end<br />
object HideProtokoll1: TMenuItem<br />
Caption = 'Hide Protokoll'<br />
OnClick = HideProtokoll1Click<br />
end<br />
object Expertmode1: TMenuItem<br />
AutoCheck = True<br />
Caption = 'Expertmode'<br />
end<br />
end<br />
end<br />
12.1.27 UNIT APA_PROCESSUNIT.PAS<br />
unit APA_Processunit;<br />
interface<br />
uses<br />
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,<br />
Dialogs, StdCtrls, ExtCtrls, Menus;<br />
type<br />
TAPA_Show_Process = class(TForm)<br />
Panel1: TPanel;<br />
ButtonCancel: TButton;<br />
GroupBox1: TGroupBox;<br />
APA_Protocoll: TListBox;<br />
ButtonPause: TButton;<br />
Ausschalten: TTimer;<br />
secretMenu1: TPopupMenu;<br />
up1: TMenuItem;<br />
down1: TMenuItem;<br />
ShowProtokoll1: TMenuItem;<br />
HideProtokoll1: TMenuItem;<br />
Expertmode1: TMenuItem;<br />
procedure ausgabe(Ausgabe:string);<br />
procedure FormShow(Sender: TObject);<br />
procedure ButtonCancelClick(Sender: TObject);<br />
procedure ButtonPauseClick(Sender: TObject);<br />
procedure FormClose(Sender: TObject; var Action: TCloseAction);<br />
procedure AusschaltenTimer(Sender: TObject);<br />
procedure GroupBox1DblClick(Sender: TObject);<br />
procedure up1Click(Sender: TObject);<br />
procedure down1Click(Sender: TObject);<br />
procedure ShowProtokoll1Click(Sender: TObject);<br />
procedure HideProtokoll1Click(Sender: TObject);<br />
private<br />
{ Private-Deklarationen }<br />
public<br />
{ Public-Deklarationen }<br />
end;<br />
var<br />
APA_Show_Process: TAPA_Show_Process;<br />
stop, break:boolean;<br />
implementation<br />
- 435 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
uses APA_Dialogunit;<br />
{$R *.dfm}<br />
var showprotokoll:boolean=true;<br />
procedure TAPA_Show_Process.ausgabe(Ausgabe:string);<br />
begin;<br />
if showprotokoll=true then begin<br />
APA_Show_Process.APA_Protocoll.Items.Add(Ausgabe);<br />
end;<br />
end;<br />
APA_Show_Process.APA_Protocoll.ItemIndex:=APA_Show_Process.APA_Protocoll.Items.Cou<br />
nt-1;<br />
Application.ProcessMessages;<br />
procedure TAPA_Show_Process.FormShow(Sender: TObject);<br />
begin<br />
stop:=false;<br />
end;<br />
procedure TAPA_Show_Process.ButtonCancelClick(Sender: TObject);<br />
begin<br />
stop:=true;<br />
break:=false;<br />
Ausschalten.Enabled:=false;<br />
APA_Show_Process.ButtonPause.Visible:=true;<br />
Close;<br />
end;<br />
procedure TAPA_Show_Process.ButtonPauseClick(Sender: TObject);<br />
begin<br />
if break=false then begin<br />
break:=true;<br />
ButtonPause.Caption:='Resume';<br />
end else begin<br />
break:=false;<br />
ButtonPause.Caption:='Pause';<br />
end;<br />
end;<br />
procedure TAPA_Show_Process.FormClose(Sender: TObject;<br />
var Action: TCloseAction);<br />
begin<br />
Stop:=true;<br />
break:=false;<br />
showprotokoll:=true;<br />
APA_Show_Process.ButtonCancel.Caption:='Abort';<br />
end;<br />
procedure TAPA_Show_Process.AusschaltenTimer(Sender: TObject);<br />
begin<br />
Ausschalten.Enabled:=false;<br />
APA_Show_Process.ButtonPause.Visible:=true;<br />
Close;<br />
end;<br />
procedure TAPA_Show_Process.GroupBox1DblClick(Sender: TObject);<br />
begin<br />
Groupbox1.PopupMenu:=secretMenu1;<br />
end;<br />
procedure TAPA_Show_Process.up1Click(Sender: TObject);<br />
begin<br />
APA_Dialog.APA_Text.Caption:='Are you sure?';<br />
if APA_Dialog.showmodal=mryes then<br />
Groupbox1.Tag:=1;<br />
end;<br />
procedure TAPA_Show_Process.down1Click(Sender: TObject);<br />
begin<br />
APA_Dialog.APA_Text.Caption:='Are you sure?';<br />
- 436 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if APA_Dialog.showmodal=mryes then<br />
Groupbox1.Tag:=-1;<br />
end;<br />
procedure TAPA_Show_Process.ShowProtokoll1Click(Sender: TObject);<br />
begin<br />
showprotokoll:=true;<br />
end;<br />
procedure TAPA_Show_Process.HideProtokoll1Click(Sender: TObject);<br />
begin<br />
showprotokoll:=false;<br />
end;<br />
end.<br />
12.1.28 UNIT APA_SCREENUNIT.DFM<br />
object APA_Screen: TAPA_Screen<br />
Left = 308<br />
Top = 209<br />
BorderStyle = bsNone<br />
Caption = 'APA_Screen'<br />
ClientHeight = 182<br />
ClientWidth = 233<br />
Color = clWhite<br />
Font.Charset = DEFAULT_CHARSET<br />
Font.Color = clWindowText<br />
Font.Height = -11<br />
Font.Name = 'MS Sans Serif'<br />
Font.Style = []<br />
FormStyle = fsStayOnTop<br />
OldCreateOrder = False<br />
Position = poScreenCenter<br />
OnClick = FormClick<br />
OnCreate = FormCreate<br />
PixelsPerInch = 96<br />
TextHeight = 13<br />
object Shape1: TShape<br />
Left = 0<br />
Top = 0<br />
Width = 233<br />
Height = 182<br />
Align = alClient<br />
Pen.Color = clGreen<br />
Pen.Width = 2<br />
OnMouseDown = Shape2MouseDown<br />
end<br />
object Shape2: TShape<br />
Left = 4<br />
Top = 4<br />
Width = 225<br />
Height = 173<br />
Pen.Color = clGreen<br />
OnMouseDown = Shape2MouseDown<br />
end<br />
object Image1: TImage<br />
Left = 69<br />
Top = 32<br />
Width = 95<br />
Height = 90<br />
AutoSize = True<br />
Picture.Data = {<br />
07544269746D6170F6250000424DF62500000000000036040000280000005F00<br />
00005A0000000100080000000000C0210000120B0000120B0000000100000000<br />
000000000000330000006600000099000000CC000000FF000000003300003333<br />
. . .<br />
. . .<br />
D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7<br />
D700D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7<br />
D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7<br />
- 437 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7<br />
D700}<br />
OnClick = Image1Click<br />
end<br />
object Label1: TLabel<br />
Left = 19<br />
Top = 8<br />
Width = 195<br />
Height = 23<br />
Caption = 'APA Application'<br />
Font.Charset = DEFAULT_CHARSET<br />
Font.Color = clGreen<br />
Font.Height = -21<br />
Font.Name = 'Courier New'<br />
Font.Style = [fsBold]<br />
ParentFont = False<br />
end<br />
object Label2: TLabel<br />
Left = 62<br />
Top = 120<br />
Width = 110<br />
Height = 18<br />
Caption = 'designed by'<br />
Font.Charset = DEFAULT_CHARSET<br />
Font.Color = clGreen<br />
Font.Height = -16<br />
Font.Name = 'Courier New'<br />
Font.Style = [fsBold]<br />
ParentFont = False<br />
end<br />
object Label3: TLabel<br />
Left = 62<br />
Top = 140<br />
Width = 110<br />
Height = 18<br />
Caption = 'Thomas ACHS'<br />
Font.Charset = DEFAULT_CHARSET<br />
Font.Color = clGreen<br />
Font.Height = -16<br />
Font.Name = 'Courier New'<br />
Font.Style = [fsBold]<br />
ParentFont = False<br />
end<br />
object Label4: TLabel<br />
Left = 69<br />
Top = 161<br />
Width = 100<br />
Height = 10<br />
Align = alCustom<br />
Alignment = taCenter<br />
Caption = ' Starting Program...'<br />
Font.Charset = DEFAULT_CHARSET<br />
Font.Color = clWindowText<br />
Font.Height = -9<br />
Font.Name = 'Lucida Sans Typewriter'<br />
Font.Style = []<br />
ParentFont = False<br />
end<br />
object Timer1: TTimer<br />
Interval = 100<br />
OnTimer = Timer1Timer<br />
Left = 32<br />
Top = 48<br />
end<br />
end<br />
12.1.29 UNIT APA_SCREENUNIT.PAS<br />
unit APA_Screenunit;<br />
interface<br />
- 438 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
uses<br />
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,<br />
Dialogs, ExtCtrls, StdCtrls, DB, DBTables;<br />
type<br />
TAPA_Screen = class(TForm)<br />
Image1: TImage;<br />
Shape1: TShape;<br />
Shape2: TShape;<br />
Label1: TLabel;<br />
Label2: TLabel;<br />
Label3: TLabel;<br />
Timer1: TTimer;<br />
Label4: TLabel;<br />
procedure FormClick(Sender: TObject);<br />
procedure Image1Click(Sender: TObject);<br />
procedure Shape2MouseDown(Sender: TObject; Button: TMouseButton;<br />
Shift: TShiftState; X, Y: Integer);<br />
procedure Timer1Timer(Sender: TObject);<br />
procedure FormCreate(Sender: TObject);<br />
private<br />
{ Private-Deklarationen }<br />
public<br />
{ Public-Deklarationen }<br />
end;<br />
var<br />
APA_Screen: TAPA_Screen;<br />
implementation<br />
uses APA_Applicationunit;<br />
{$R *.dfm}<br />
var counter:longint=0;<br />
procedure TAPA_Screen.FormClick(Sender: TObject);<br />
begin<br />
Counter:=100;<br />
end;<br />
procedure TAPA_Screen.Image1Click(Sender: TObject);<br />
begin<br />
Counter:=100;<br />
end;<br />
procedure TAPA_Screen.Shape2MouseDown(Sender: TObject;<br />
Button: TMouseButton; Shift: TShiftState; X, Y: Integer);<br />
begin<br />
Counter:=100;<br />
end;<br />
procedure TAPA_Screen.Timer1Timer(Sender: TObject);<br />
begin<br />
counter:=counter+1;<br />
if counter=10 then Label4.Caption:=' Loading Settings...';<br />
if counter=25 then Label4.Caption:=' Ready to start...';<br />
if counter>30 then begin;<br />
Timer1.Enabled:=false;<br />
APA_Screen.Hide;<br />
APA_Application.showmodal;<br />
Close;<br />
end;<br />
end;<br />
procedure TAPA_Screen.FormCreate(Sender: TObject);<br />
begin<br />
CurrencyString:='';<br />
ShortDateFormat:='dd.mm.yyyy';<br />
LongDateFormat:='dd.mm.yyyy';<br />
DateSeparator := '.';<br />
ThousandSeparator:='.';<br />
- 439 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
DecimalSeparator:=',';<br />
CurrencyDecimals:=2;<br />
ShortTimeFormat:='hh:nn';<br />
LongTimeFormat:='hh:nn';<br />
end;<br />
end.<br />
12.1.30 UNIT APA_SELECTIONUNIT.DFM<br />
object APA_Selection_Screen: TAPA_Selection_Screen<br />
Left = 100<br />
Top = 115<br />
Width = 760<br />
Height = 551<br />
Caption = 'APA Selection Screen'<br />
Color = clBtnFace<br />
Font.Charset = DEFAULT_CHARSET<br />
Font.Color = clWindowText<br />
Font.Height = -11<br />
Font.Name = 'MS Sans Serif'<br />
Font.Style = []<br />
OldCreateOrder = False<br />
OnShow = FormShow<br />
PixelsPerInch = 96<br />
TextHeight = 13<br />
object Panel2: TPanel<br />
Left = 0<br />
Top = 476<br />
Width = 752<br />
Height = 41<br />
Align = alBottom<br />
TabOrder = 0<br />
object Button_show_current_APA: TButton<br />
Left = 8<br />
Top = 8<br />
Width = 155<br />
Height = 25<br />
Caption = 'Show current APA'<br />
ModalResult = 3<br />
TabOrder = 0<br />
OnClick = Button_show_current_APAClick<br />
end<br />
object Button_delete_all: TButton<br />
Left = 330<br />
Top = 8<br />
Width = 155<br />
Height = 25<br />
Caption = 'Delete all req. blocks && cubes'<br />
TabOrder = 1<br />
OnClick = Button_delete_allClick<br />
end<br />
object Button_add_to_selection: TButton<br />
Left = 169<br />
Top = 8<br />
Width = 155<br />
Height = 25<br />
Caption = 'Add to selection'<br />
Enabled = False<br />
ModalResult = 4<br />
TabOrder = 2<br />
OnClick = Button_add_to_selectionClick<br />
end<br />
object Button_Main_Menu: TButton<br />
Left = 490<br />
Top = 8<br />
Width = 155<br />
Height = 25<br />
Caption = 'Back to Main Menu'<br />
TabOrder = 3<br />
OnClick = Button_Main_MenuClick<br />
- 440 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
end<br />
end<br />
object GroupBox1: TGroupBox<br />
Left = 0<br />
Top = 0<br />
Width = 752<br />
Height = 145<br />
Align = alTop<br />
Caption = 'Selection'<br />
TabOrder = 1<br />
object Label1: TLabel<br />
Left = 120<br />
Top = 20<br />
Width = 52<br />
Height = 13<br />
Caption = 'Dimension:'<br />
end<br />
object Label2: TLabel<br />
Left = 124<br />
Top = 44<br />
Width = 48<br />
Height = 13<br />
Caption = 'Hierarchy:'<br />
end<br />
object Label3: TLabel<br />
Left = 133<br />
Top = 68<br />
Width = 39<br />
Height = 13<br />
Caption = 'Method:'<br />
end<br />
object Label4: TLabel<br />
Left = 100<br />
Top = 92<br />
Width = 72<br />
Height = 13<br />
Caption = 'End of method:'<br />
end<br />
object Dimensionbox: TComboBox<br />
Left = 184<br />
Top = 16<br />
Width = 421<br />
Height = 21<br />
Style = csDropDownList<br />
ItemHeight = 13<br />
ItemIndex = 0<br />
TabOrder = 0<br />
Text = 'NONE'<br />
OnChange = DimensionboxChange<br />
Items.Strings = (<br />
'NONE')<br />
end<br />
object Hierarchybox: TComboBox<br />
Left = 184<br />
Top = 40<br />
Width = 421<br />
Height = 21<br />
Style = csDropDownList<br />
ItemHeight = 13<br />
ItemIndex = 0<br />
TabOrder = 2<br />
Text = 'NONE'<br />
OnChange = HierarchyboxChange<br />
Items.Strings = (<br />
'NONE')<br />
end<br />
object Methodbox: TComboBox<br />
Left = 184<br />
Top = 64<br />
Width = 421<br />
Height = 21<br />
Style = csDropDownList<br />
ItemHeight = 13<br />
ItemIndex = 0<br />
- 441 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
TabOrder = 4<br />
Text = 'NONE'<br />
OnChange = HierarchyboxChange<br />
Items.Strings = (<br />
'NONE'<br />
'DRILL DOWN'<br />
'ROLL UP')<br />
end<br />
object End_of_methodbox: TComboBox<br />
Left = 184<br />
Top = 88<br />
Width = 421<br />
Height = 21<br />
Style = csDropDownList<br />
ItemHeight = 13<br />
ItemIndex = 0<br />
TabOrder = 6<br />
Text = 'NONE'<br />
Items.Strings = (<br />
'NONE')<br />
end<br />
object Button_insert: TButton<br />
Left = 186<br />
Top = 111<br />
Width = 77<br />
Height = 25<br />
Caption = 'Insert'<br />
TabOrder = 8<br />
OnClick = Button_insertClick<br />
end<br />
object Button_delete: TButton<br />
Left = 265<br />
Top = 111<br />
Width = 77<br />
Height = 25<br />
Caption = 'Delete'<br />
Enabled = False<br />
TabOrder = 1<br />
OnClick = Button_deleteClick<br />
end<br />
object Button_Edit: TButton<br />
Left = 345<br />
Top = 111<br />
Width = 77<br />
Height = 25<br />
Caption = 'Edit'<br />
Enabled = False<br />
TabOrder = 3<br />
OnClick = Button_EditClick<br />
end<br />
object Button_Accept: TButton<br />
Left = 424<br />
Top = 111<br />
Width = 75<br />
Height = 25<br />
Caption = 'Accept'<br />
TabOrder = 5<br />
OnClick = Button_AcceptClick<br />
end<br />
object Button_Cancel: TButton<br />
Left = 504<br />
Top = 111<br />
Width = 75<br />
Height = 25<br />
Caption = 'Cancel'<br />
TabOrder = 7<br />
OnClick = Button_CancelClick<br />
end<br />
end<br />
object Listeint: TListBox<br />
Left = 602<br />
Top = 145<br />
Width = 150<br />
Height = 331<br />
- 442 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Align = alRight<br />
ItemHeight = 13<br />
TabOrder = 2<br />
Visible = False<br />
end<br />
object Panel1: TPanel<br />
Left = 0<br />
Top = 145<br />
Width = 193<br />
Height = 331<br />
Align = alLeft<br />
TabOrder = 3<br />
object Panel3: TPanel<br />
Left = 1<br />
Top = 1<br />
Width = 191<br />
Height = 238<br />
Align = alTop<br />
TabOrder = 0<br />
object Button_new_requirement_block: TButton<br />
Left = 8<br />
Top = 8<br />
Width = 169<br />
Height = 25<br />
Caption = 'New req. block'<br />
TabOrder = 0<br />
OnClick = Button_new_requirement_blockClick<br />
end<br />
object Button_del_req_block: TButton<br />
Left = 8<br />
Top = 61<br />
Width = 169<br />
Height = 25<br />
Caption = 'Delete req. block'<br />
Enabled = False<br />
TabOrder = 1<br />
OnClick = Button_del_req_blockClick<br />
end<br />
object Button_select: TButton<br />
Left = 8<br />
Top = 88<br />
Width = 169<br />
Height = 25<br />
Caption = 'Select'<br />
Enabled = False<br />
TabOrder = 2<br />
OnClick = Button_selectClick<br />
end<br />
object Button_Deselect: TButton<br />
Left = 8<br />
Top = 115<br />
Width = 169<br />
Height = 25<br />
Caption = 'Deselect'<br />
Enabled = False<br />
TabOrder = 3<br />
OnClick = Button_DeselectClick<br />
end<br />
object Button_Select_all: TButton<br />
Left = 8<br />
Top = 142<br />
Width = 169<br />
Height = 25<br />
Caption = 'Select all'<br />
TabOrder = 4<br />
OnClick = Button_Select_allClick<br />
end<br />
object Button_Deselect_all: TButton<br />
Left = 8<br />
Top = 169<br />
Width = 169<br />
Height = 25<br />
Caption = 'Deselect all'<br />
TabOrder = 5<br />
- 443 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
OnClick = Button_Deselect_allClick<br />
end<br />
object Button_Edit_Requirement_block: TButton<br />
Left = 7<br />
Top = 34<br />
Width = 169<br />
Height = 25<br />
Caption = 'Edit req. block'<br />
Enabled = False<br />
TabOrder = 6<br />
OnClick = Button_Edit_Requirement_blockClick<br />
end<br />
end<br />
end<br />
object Req: TTreeView<br />
Left = 193<br />
Top = 145<br />
Width = 409<br />
Height = 331<br />
Align = alClient<br />
Font.Charset = DEFAULT_CHARSET<br />
Font.Color = clWindowText<br />
Font.Height = -13<br />
Font.Name = 'MS Sans Serif'<br />
Font.Style = []<br />
Images = ImageList2<br />
Indent = 19<br />
ParentFont = False<br />
ReadOnly = True<br />
TabOrder = 4<br />
OnClick = ReqClick<br />
OnDblClick = ReqDblClick<br />
end<br />
object ImageList2: TImageList<br />
Left = 448<br />
Top = 288<br />
Bitmap = {<br />
494C010103000400040010001000FFFFFFFFFF10FFFFFFFFFFFFFFFF424D3600<br />
0000000000003600000028000000400000001000000001002000000000000010<br />
000000000000000000000000000000000000344E4A006BB09B006BB09B006BB0<br />
. . .<br />
. . .<br />
0000000000000000000000000000000000000000000000000000000000000000<br />
0000000000000000000000000000000000000000000000000000000000000000<br />
0000000000000000000000000000000000000000000000000000000000000000<br />
000000000000}<br />
end<br />
end<br />
12.1.31 UNIT APA_SELECTIONUNIT.PAS<br />
unit APA_Selectionunit;<br />
interface<br />
uses<br />
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,<br />
Dialogs, ImgList, ComCtrls, StdCtrls, ExtCtrls;<br />
type<br />
TAPA_Selection_Screen = class(TForm)<br />
Panel2: TPanel;<br />
Button_show_current_APA: TButton;<br />
Button_delete_all: TButton;<br />
Button_add_to_selection: TButton;<br />
Button_Main_Menu: TButton;<br />
GroupBox1: TGroupBox;<br />
Label1: TLabel;<br />
Label2: TLabel;<br />
Label3: TLabel;<br />
Label4: TLabel;<br />
Dimensionbox: TComboBox;<br />
- 444 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Hierarchybox: TComboBox;<br />
Methodbox: TComboBox;<br />
End_of_methodbox: TComboBox;<br />
Button_insert: TButton;<br />
Button_delete: TButton;<br />
Button_Edit: TButton;<br />
Button_Accept: TButton;<br />
Button_Cancel: TButton;<br />
Listeint: TListBox;<br />
Panel1: TPanel;<br />
Panel3: TPanel;<br />
Button_new_requirement_block: TButton;<br />
Button_del_req_block: TButton;<br />
Button_select: TButton;<br />
Button_Deselect: TButton;<br />
Button_Select_all: TButton;<br />
Button_Deselect_all: TButton;<br />
Button_Edit_Requirement_block: TButton;<br />
Req: TTreeView;<br />
ImageList2: TImageList;<br />
procedure DimensionboxChange(Sender: TObject);<br />
procedure HierarchyboxChange(Sender: TObject);<br />
procedure Button_new_requirement_blockClick(Sender: TObject);<br />
procedure Button_Edit_Requirement_blockClick(Sender: TObject);<br />
procedure Button_selectClick(Sender: TObject);<br />
procedure Button_DeselectClick(Sender: TObject);<br />
procedure Button_del_req_blockClick(Sender: TObject);<br />
procedure Button_insertClick(Sender: TObject);<br />
procedure ReqClick(Sender: TObject);<br />
procedure Button_Select_allClick(Sender: TObject);<br />
procedure Button_Deselect_allClick(Sender: TObject);<br />
procedure Button_deleteClick(Sender: TObject);<br />
procedure Button_EditClick(Sender: TObject);<br />
procedure Button_AcceptClick(Sender: TObject);<br />
procedure Button_CancelClick(Sender: TObject);<br />
procedure ReqDblClick(Sender: TObject);<br />
procedure Button_show_current_APAClick(Sender: TObject);<br />
procedure Button_add_to_selectionClick(Sender: TObject);<br />
procedure Button_delete_allClick(Sender: TObject);<br />
procedure FormShow(Sender: TObject);<br />
procedure Button_Main_MenuClick(Sender: TObject);<br />
private<br />
{ Private-Deklarationen }<br />
public<br />
{ Public-Deklarationen }<br />
end;<br />
var<br />
APA_Selection_Screen: TAPA_Selection_Screen;<br />
gotoAPA:boolean=false;<br />
implementation<br />
uses APA_Input_Reqblockunit, APA_Gridunit, APA_Parameterunit,<br />
APA_Optionsunit, APA_Dialogunit, APA_Applicationunit;<br />
{$R *.dfm}<br />
var editmode:boolean =false;<br />
editnode:TTreeNode;<br />
anzblocksselected:longint =0;<br />
function vergleichewuerfel(erster,zweiter:array of longint;Dimensionen:longint):longint;<br />
var zahler:longint;<br />
ergebnis0,ergebnisminus1:boolean;<br />
begin<br />
{Diese Funktion Vergleicht die beiden Würfel und gibt 1 zurück, wenn der Zweite kein<br />
Derivate des ersten ist. 0 wenn gleich und sonst -1}<br />
ergebnis0:=true;ergebnisminus1:=false;<br />
For zahler:=0 to Dimensionen-1 do begin<br />
if (erster[zahler]
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
end;<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if ergebnisminus1=true then Result:=-1<br />
else<br />
if ergebnis0=false then Result:=1<br />
else<br />
Result:=0;<br />
end;<br />
function getbezeichnung():string;<br />
var st2,st:string;<br />
begin;<br />
{Diese Funktion erzeugt die Bezeichnung für den Eintrag in der Anzeige}<br />
with APA_Selection_Screen do begin<br />
{Auflösen der Bezeichnung in der Spezialbox}<br />
st2:=inttostr(dimensionbox.itemindex);while length(st2)
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
then begin<br />
if<br />
strtoint(copy(Listeint.Items[zahler],1,4))=Dimensionbox.ItemIndex then<br />
zusetzen:=false;<br />
end;<br />
zahler:=zahler-1;if zahler0 then begin<br />
while(copy(Listeint.Items[aktindex],1,4)'Req:')and(aktindex>0) do begin<br />
aktindex:=aktindex-1;<br />
end;<br />
if Req.Items[aktindex].ImageIndex2 then aktiviert:=true;<br />
end;<br />
if Editmode=true then begin<br />
{Links alles deaktivieren}<br />
Button_Edit_Requirement_Block.Enabled:=false;<br />
Button_new_requirement_block.Enabled:=false;<br />
Button_del_req_block.Enabled:=false;<br />
Button_select.Enabled:=false;<br />
Button_Deselect.Enabled:=false;<br />
Button_Select_all.Enabled:=false;<br />
Button_Deselect_all.Enabled:=false;<br />
{Unten alles deaktivieren}<br />
Button_show_current_APA.Enabled:=false;<br />
Button_add_to_selection.Enabled:=false;<br />
Button_delete_all.Enabled:=false;<br />
{Oben nur Accept und Cancel aktivieren}<br />
Button_Insert.Enabled:=false;<br />
Button_Edit.Enabled:=false;<br />
Button_Delete.Enabled:=false;<br />
Button_Accept.Enabled:=true;<br />
Button_Cancel.Enabled:=true;<br />
Req.Enabled:=false;<br />
end<br />
else<br />
begin;<br />
{Unten alles aktivieren}<br />
{anzblocksselected gibt die Anzahl der Selektieren Blocks wieder}<br />
if anzblocksselected0 then begin;<br />
- 447 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Button_show_current_APA.Enabled:=false;<br />
Button_add_to_selection.Enabled:=true;<br />
end else begin<br />
Button_show_current_APA.Enabled:=true;<br />
Button_add_to_selection.Enabled:=false;<br />
end;<br />
Button_delete_all.Enabled:=true;<br />
if req.selectednil then begin<br />
if aktiviert=true then begin<br />
Button_Edit_Requirement_Block.Enabled:=true;<br />
Button_new_requirement_block.Enabled:=true;<br />
Button_del_req_block.Enabled:=true;<br />
end else begin<br />
Button_Edit_Requirement_Block.Enabled:=false;<br />
Button_new_requirement_block.Enabled:=true;<br />
Button_del_req_block.Enabled:=false;<br />
end;<br />
Button_Select_all.Enabled:=true;<br />
Button_Deselect_all.Enabled:=true;<br />
if req.Selected.Level=0 then begin<br />
if req.Selected.ImageIndex=0 then begin<br />
Button_select.Enabled:=true;<br />
Button_Deselect.Enabled:=false;<br />
end<br />
else<br />
begin<br />
if req.Selected.ImageIndex=1 then begin<br />
Button_select.Enabled:=false;<br />
Button_Deselect.Enabled:=true;<br />
end else begin<br />
//Bereits zugesetzt<br />
Button_select.Enabled:=false;<br />
Button_Deselect.Enabled:=false;<br />
end;<br />
end;<br />
{Ist eine Hierarchie ausgewählt dann alle deaktiveren außer insert}<br />
if aktiviert=true then<br />
Button_Insert.Enabled:=true<br />
else<br />
Button_Insert.Enabled:=false;<br />
Button_Edit.Enabled:=false;<br />
Button_Delete.Enabled:=false;<br />
Button_Accept.Enabled:=false;<br />
Button_Cancel.Enabled:=false;<br />
Req.Enabled:=true;<br />
end {of level 0}<br />
else begin<br />
{begin von level 1}<br />
Button_Edit_Requirement_Block.Enabled:=false;<br />
if aktiviert=true then<br />
Button_new_requirement_block.Enabled:=true<br />
else<br />
Button_new_requirement_block.Enabled:=true;<br />
Button_del_req_block.Enabled:=false;<br />
Button_select.Enabled:=false;<br />
Button_Deselect.Enabled:=false;<br />
if aktiviert=true then begin<br />
Button_Insert.Enabled:=true;<br />
Button_Edit.Enabled:=true;<br />
Button_Delete.Enabled:=true;<br />
end<br />
else<br />
begin<br />
Button_Insert.Enabled:=false;<br />
Button_Edit.Enabled:=false;<br />
Button_Delete.Enabled:=false;<br />
- 448 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Req.Enabled:=false;<br />
end;<br />
Button_Accept.Enabled:=false;<br />
Button_Cancel.Enabled:=false;<br />
Req.Enabled:=true;<br />
end;<br />
end else begin<br />
{Wenn nichts ausgewählt}<br />
{Buttons links}<br />
Button_Edit_Requirement_Block.Enabled:=false;<br />
Button_new_requirement_block.Enabled:=true;<br />
Button_del_req_block.Enabled:=false;<br />
{Buttons oben}<br />
if aktiviert=true then<br />
Button_Insert.Enabled:=true<br />
else<br />
Button_Insert.Enabled:=false;<br />
Button_Edit.Enabled:=false;<br />
Button_Delete.Enabled:=false;<br />
Button_Accept.Enabled:=false;<br />
Button_Cancel.Enabled:=false;<br />
Req.Enabled:=true;<br />
end;<br />
end;{of editmode}<br />
end;<br />
end;<br />
procedure TAPA_Selection_Screen.DimensionboxChange(Sender: TObject);<br />
var zahler:longint;<br />
begin<br />
if Dimensionbox.Text'NONE' then begin<br />
hierarchybox.Items.Clear;<br />
{Hole die Hierarchiestufen}<br />
for zahler:=0 to anzh[Dimensionbox.itemindex]-1 do begin<br />
Hierarchybox.Items.Add(dl[Dimensionbox.itemindex][zahler])<br />
end;<br />
Hierarchybox.ItemIndex:=0;<br />
Methodbox.ItemIndex:=0;<br />
end;<br />
end;<br />
procedure TAPA_Selection_Screen.HierarchyboxChange(Sender: TObject);<br />
var zahler:longint;<br />
begin<br />
if Methodbox.itemindex0 then begin<br />
End_of_methodbox.Enabled:=true;<br />
if Methodbox.ItemIndex=2 then begin<br />
{Bei einem Roll up}<br />
End_of_Methodbox.Items.Clear;<br />
{Hole die Hierarchiestufen}<br />
for zahler:=hierarchybox.itemindex+1 to anzh[Dimensionbox.itemindex]-1 do begin<br />
End_of_Methodbox.Items.Add(dl[Dimensionbox.itemindex][zahler])<br />
end;<br />
end else<br />
begin<br />
{Bei einem DRILL DOWN}<br />
End_of_Methodbox.Items.Clear;<br />
{Hole die Hierarchiestufen}<br />
for zahler:=0 to hierarchybox.itemindex-1 do begin<br />
End_of_Methodbox.Items.Add(dl[Dimensionbox.itemindex][zahler])<br />
end;<br />
- 449 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
end;<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
end else begin;<br />
End_of_methodbox.Enabled:=false;<br />
End_of_methodbox.Items.Add('NONE');<br />
end;<br />
if End_of_Methodbox.Items.Count=0 then begin;<br />
Methodbox.ItemIndex:=0;<br />
End_of_methodbox.Enabled:=false;<br />
End_of_methodbox.Items.Add('NONE');<br />
end;<br />
End_of_methodbox.ItemIndex:=0;<br />
end;<br />
procedure TAPA_Selection_Screen.Button_new_requirement_blockClick(<br />
Sender: TObject);<br />
var g:longint;<br />
importancestring:string;<br />
merkindex:longint;<br />
ok:boolean;<br />
begin<br />
mustsave:=true;<br />
{Ein Req}<br />
APA_Insert_Reqblock.Reqname.Text:='';<br />
APA_Insert_Reqblock.OKBtn.Enabled:=false;<br />
APA_insert_Reqblock.Add_max_hier.Visible:=APA_Options.APA_Add_max_hier.checked;<br />
APA_Insert_Reqblock.Add_max_hier.Enabled:=true;<br />
repeat;<br />
ok:=true;<br />
if APA_Insert_Reqblock.showmodal=mrok then begin<br />
for merkindex:=0 to Req.Items.Count-1 do begin<br />
if copy(Listeint.Items[merkindex],1,3)='Req' then begin<br />
if (copy(Req.items[merkindex].text,1,pos('//',Req.items[merkindex].Text)-1)=<br />
APA_Insert_reqblock.reqname.Text) then begin<br />
ok:=false;<br />
showmessage('The name '+APA_Insert_reqblock.reqname.Text+' is already used. Please<br />
change the name!');<br />
end;<br />
end;<br />
end;<br />
if ok=true then begin<br />
if Req.TopItemnil then Req.Selected:=Req.TopItem;<br />
importancestring:=APA_Parameter.APA_Degrees.Items[APA_Insert_Reqblock.Importance_o<br />
f_requirement.Itemindex];<br />
merkindex:=Req.Items.Add(req.Selected,APA_Insert_reqblock.reqname.Text+'//'+import<br />
ancestring).AbsoluteIndex;<br />
Req.Items[merkindex].ImageIndex:=0;<br />
Req.Items[merkindex].SelectedIndex:=0;<br />
Req.Selected:=Req.Items[Req.Items.count-1];<br />
Listeint.Items.Add('Req:'+inttostr(APA_Insert_Reqblock.Importance_of_requirement.I<br />
temindex));<br />
if APA_insert_Reqblock.Add_max_hier.Checked=true then begin<br />
{Zusetzen aller Dimensionen mit max. Hierarchielevels}<br />
for g:=0 to Dimensionbox.Items.Count-1 do begin;<br />
{Dimension einstellen}<br />
Dimensionbox.ItemIndex:=g;DimensionboxChange(self);<br />
{max Hierarchie einstellen}<br />
- 450 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
end;<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Hierarchybox.ItemIndex:=Hierarchybox.items.count-1;<br />
{Methode ist Keine}<br />
Methodbox.ItemIndex:=0;<br />
{End of Methode ist auch keine}<br />
End_of_Methodbox.ItemIndex:=0;<br />
Button_insertClick(self);<br />
end;<br />
end;//von ok<br />
end else ok:=true;<br />
until ok=true;<br />
{Ein Req ENDE}<br />
buttonreqchange;<br />
Req.SetFocus;<br />
end;<br />
procedure TAPA_Selection_Screen.Button_Edit_Requirement_blockClick(<br />
Sender: TObject);<br />
var importancestring:string;<br />
var ok:boolean;<br />
var merkindex:longint;<br />
begin<br />
if Req.Selectednil then begin<br />
try<br />
{Ein Req}<br />
APA_Insert_Reqblock.Reqname.Text:=copy(Req.Selected.text,1,pos('//',Req.Selected.T<br />
ext)-1);<br />
APA_Insert_Reqblock.OKBtn.Enabled:=false;<br />
APA_insert_Reqblock.Add_max_hier.Visible:=false;<br />
APA_Insert_Reqblock.Importance_of_requirement.ItemIndex:=<br />
strtoint(copy(Listeint.Items[Req.Selected.Absoluteindex],5,255));<br />
repeat;<br />
ok:=true;<br />
if APA_Insert_Reqblock.showmodal=mrok then begin<br />
for merkindex:=0 to Req.Items.Count-1 do begin<br />
if copy(Listeint.Items[merkindex],1,3)='Req' then begin<br />
if (copy(Req.items[merkindex].text,1,pos('//',Req.items[merkindex].Text)-1)=<br />
APA_Insert_reqblock.reqname.Text)and(Req.SelectedReq.Items[merkindex]) then<br />
begin<br />
ok:=false;<br />
showmessage('The name '+APA_Insert_reqblock.reqname.Text+' is already used. Please<br />
change the name!');<br />
end;<br />
end;<br />
end;<br />
if ok=true then begin<br />
importancestring:=APA_Parameter.APA_Degrees.Items[APA_Insert_Reqblock.Importance_o<br />
f_requirement.Itemindex];<br />
Req.Selected.Text:=APA_Insert_Reqblock.reqname.Text+'//'+importancestring;<br />
Listeint.Items[Req.Selected.Absoluteindex]:='Req:'+inttostr(APA_Insert_Reqblock.Im<br />
portance_of_requirement.Itemindex);<br />
mustsave:=true;<br />
end;//of ok<br />
- 451 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
end else ok:=true;<br />
until ok=true;<br />
{Ein Req ENDE}<br />
buttonreqchange;<br />
except<br />
showmessage('Fehler beim Auflösen der Daten');<br />
buttonreqchange;<br />
exit;<br />
end;<br />
Req.SetFocus;<br />
end;<br />
end;<br />
procedure TAPA_Selection_Screen.Button_selectClick(Sender: TObject);<br />
begin<br />
Req.Selected.ImageIndex:=1;<br />
Req.Selected.SelectedIndex:=1;<br />
anzblocksselected:=anzblocksselected+1;<br />
buttonreqchange;<br />
end;<br />
procedure TAPA_Selection_Screen.Button_DeselectClick(Sender: TObject);<br />
begin<br />
if Req.Selected.ImageIndex=1 then begin<br />
Req.Selected.ImageIndex:=0;<br />
Req.Selected.SelectedIndex:=0;<br />
anzblocksselected:=anzblocksselected-1;<br />
buttonreqchange;<br />
end;<br />
end;<br />
procedure TAPA_Selection_Screen.Button_del_req_blockClick(Sender: TObject);<br />
var loschebis,zahler:longint;<br />
begin<br />
{Löschen der Einträge in Listeint}<br />
{1. Lösch so lange bis das nächste Req kommt}<br />
loschebis:=Req.Selected.AbsoluteIndex;<br />
repeat;<br />
loschebis:=loschebis+1;<br />
until(copy(Listeint.items[loschebis+1],1,4)='Req:')<br />
or(loschebis+1=Listeint.Items.Count-1);<br />
if loschebis+1=Listeint.Items.Count-1 then loschebis:=loschebis+1;<br />
for zahler:=0 to (loschebis-Req.Selected.AbsoluteIndex)<br />
do Listeint.Items.Delete(Req.Selected.AbsoluteIndex);<br />
Req.Selected.Delete;<br />
buttonreqchange;<br />
mustsave:=true;<br />
end;<br />
procedure TAPA_Selection_Screen.Button_insertClick(Sender: TObject);<br />
var st,st2:string;<br />
x:longint;<br />
begin<br />
if req.Selected=nil then begin;<br />
APA_Insert_Reqblock.Add_max_hier.Enabled:=true;<br />
APA_Insert_Reqblock.Add_max_hier.Checked:=false;<br />
Button_new_requirement_block.Click;<br />
Req.SetFocus;<br />
end;<br />
st2:=getbezeichnung(); {speichern der Spezialbezeichnung in st2}<br />
if kannzusetzen()=true then begin{Zusetzen der Bezeichnung}<br />
{Zusetzen der Anzeigebezeichnung in die Liste}<br />
st:='Choose from '+Dimensionbox.Text+' hierarchy '+hierarchybox.text;<br />
- 452 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if Methodbox.ItemIndex0 then begin<br />
st:=st+' and a '+Methodbox.Text+' to '+End_of_Methodbox.Text;<br />
end;<br />
if req.Selected.Level=0 then<br />
{wenn Dimension markiert}<br />
x:=Req.Items.AddChild(Req.Selected,<br />
st).AbsoluteIndex<br />
else<br />
{wenn Hierarchy markiert}<br />
x:=Req.Items.Add(Req.Selected,<br />
st).AbsoluteIndex;<br />
{Zusetzen der Spezialbezeichnung in die Liste}<br />
Listeint.Items.insert(x, st2);<br />
Req.Items[x].ImageIndex:=6;<br />
Req.Items[x].SelectedIndex:=6;<br />
Req.selected.expand(true);<br />
mustsave:=true;<br />
end{End of Zusetzen}<br />
else<br />
showmessage('Diese Hierarchie wurde bereits zugesetzt');<br />
buttonreqchange;<br />
end;<br />
procedure TAPA_Selection_Screen.ReqClick(Sender: TObject);<br />
begin<br />
buttonreqchange;<br />
end;<br />
procedure TAPA_Selection_Screen.Button_Select_allClick(Sender: TObject);<br />
var zahler:longint;<br />
begin<br />
anzblocksselected:=0;<br />
for zahler:=0 to Req.Items.Count-1 do begin<br />
if (req.items[zahler].Level=0)and(req.Items[zahler].ImageIndex2) then begin<br />
Req.items[zahler].ImageIndex:=1;<br />
Req.items[zahler].SelectedIndex:=1;<br />
anzblocksselected:=anzblocksselected+1;<br />
end;<br />
end;<br />
Req.Repaint;<br />
buttonreqchange;<br />
end;<br />
procedure TAPA_Selection_Screen.Button_Deselect_allClick(Sender: TObject);<br />
var zahler:longint;<br />
begin<br />
for zahler:=0 to req.Items.Count-1 do begin<br />
if (req.items[zahler].Level=0)and(Req.items[zahler].ImageIndex2) then begin<br />
Req.items[zahler].ImageIndex:=0;<br />
Req.items[zahler].SelectedIndex:=0;<br />
end;<br />
end;<br />
Req.Repaint;<br />
buttonreqchange;<br />
anzblocksselected:=0;<br />
buttonreqchange;<br />
end;<br />
procedure TAPA_Selection_Screen.Button_deleteClick(Sender: TObject);<br />
begin<br />
Listeint.Items.Delete(Req.Selected.AbsoluteIndex);<br />
Req.Selected.Delete;<br />
- 453 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
buttonreqchange;<br />
mustsave:=true;<br />
end;<br />
procedure TAPA_Selection_Screen.Button_EditClick(Sender: TObject);<br />
var st:string;<br />
begin<br />
if Req.Selectednil then begin<br />
editnode:=Req.Selected;<br />
editmode:=true;<br />
{Daten laden}<br />
st:=Listeint.Items[Req.Selected.Absoluteindex];<br />
try<br />
Dimensionbox.ItemIndex:=strtoint(copy(st,1,4));DimensionboxChange(self);<br />
Hierarchybox.ItemIndex:=strtoint(copy(st,5,4));<br />
Methodbox.ItemIndex:=strtoint(copy(st,9,4));<br />
End_of_methodbox.ItemIndex:=strtoint(copy(st,13,4));<br />
mustsave:=true;<br />
except<br />
showmessage('Fehler beim Auflösen der Daten');<br />
editmode:=false;buttonreqchange;<br />
exit;<br />
end;<br />
end;<br />
buttonreqchange;<br />
end;<br />
procedure TAPA_Selection_Screen.Button_AcceptClick(Sender: TObject);<br />
var st:string;<br />
begin<br />
editnode.Selected:=true;<br />
if kannzusetzen()=true then begin{Zusetzen der Bezeichnung}<br />
{Zusetzen der Anzeigebezeichnung in die Liste}<br />
st:='Choose from '+Dimensionbox.Text+' hierarchy '+hierarchybox.text;<br />
if Methodbox.ItemIndex0 then begin<br />
st:=st+' and a '+Methodbox.Text+' to '+End_of_Methodbox.Text;<br />
end;<br />
Req.Selected.Text:=st;<br />
{Zusetzen der Spezialbezeichnung in die Liste}<br />
Listeint.Items[Req.Selected.AbsoluteIndex]:=getbezeichnung();<br />
Req.selected.expand(true);<br />
mustsave:=true;<br />
end{End of Zusetzen}<br />
else<br />
showmessage('Diese Hierarchie wurde bereits zugesetzt');<br />
editmode:=false;<br />
buttonreqchange;<br />
end;<br />
procedure TAPA_Selection_Screen.Button_CancelClick(Sender: TObject);<br />
begin<br />
editmode:=false;<br />
buttonreqchange;<br />
end;<br />
procedure TAPA_Selection_Screen.ReqDblClick(Sender: TObject);<br />
begin<br />
if copy(Listeint.items[Req.Selected.AbsoluteIndex],1,4)'Req:' then begin<br />
if Button_Edit.Enabled=true then begin<br />
Button_Edit.Click;<br />
- 454 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
end<br />
else showmessage('Edit not allowed');<br />
end;<br />
end;<br />
procedure TAPA_Selection_Screen.Button_show_current_APAClick(<br />
Sender: TObject);<br />
begin<br />
gotoAPA:=true;<br />
end;<br />
procedure TAPA_Selection_Screen.Button_add_to_selectionClick(<br />
Sender: TObject);<br />
var akth:array of longint;<br />
newbegin,newende,newakt:array of longint;<br />
zahler,zahler2:longint;<br />
begin<br />
spalte,zeile,aktdim:longint;<br />
ende,endifredundant,endedieserzeile,enderollup:boolean;<br />
copystring:string;<br />
gewicht:longint;<br />
{Zusetzen der Selektierten Cubes zum APA}<br />
mustsave:=true;<br />
{1. Feststellen des Cubes, welcher zugesetzt wird}<br />
for zahler:=0 to Listeint.Items.Count-1 do begin<br />
if(copy(Listeint.Items[zahler],1,4)='Req:')and(Req.Items[zahler].ImageIndex=1) then<br />
begin<br />
Req.Items[Zahler].ImageIndex:=2;<br />
Req.Items[Zahler].SelectedIndex:=2;<br />
gewicht:=strtoint(copy(Listeint.Items[zahler],5,255));<br />
newbegin:=nil;<br />
setlength(newbegin,anzd);<br />
newende:=nil;<br />
setlength(newende,anzd);<br />
{Alle Hierarchiestufen der Dimensionen auf max setzen}<br />
for zahler2:=0 to anzd-1 do newbegin[zahler2]:=anzh[zahler2]-1;<br />
for zahler2:=0 to anzd-1 do newende[zahler2]:=anzh[zahler2]-1;<br />
zahler2:=zahler+1;copystring:=copy(Listeint.Items[zahler2],1,4);<br />
while (copystring'Req:')and(zahler2
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
newbegin[(strtoint(copy(Listeint.Items[zahler2],1,4)))]:=strtoint(copy(Listeint.It<br />
ems[zahler2],5,4));<br />
newende[(strtoint(copy(Listeint.Items[zahler2],1,4)))]:=strtoint(copy(Listeint.Ite<br />
ms[zahler2],13,4));<br />
end;<br />
end;//Ende von Dill Down and Roll UP<br />
zahler2:=zahler2+1;<br />
if zahler2
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
if vergleichewuerfel(newakt,akth,anzd)=0 then begin;<br />
APA[spalte,zeile].interessant:=true;<br />
APA[spalte,zeile].gewicht:=strtoint(APA_Parameter.APA_Degreecounts.Items[gewicht])<br />
;;<br />
APA[spalte,zeile].gewichtlevel:=gewicht;<br />
end;<br />
end;//of Endedieserzeile<br />
end;//Ende von clYellow Redundanzfrei<br />
spalte:=spalte+1;<br />
end;//Ende von Spalten und Ende=false<br />
zeile:=zeile+1;<br />
end;//Ende von Zeilen und Ende=false<br />
enderollup:=false;<br />
until (vergleichewuerfel(newakt,newende,anzd)=0);<br />
end;//Ende von es ist ein Reqirement<br />
end;//Ende von zahler<br />
anzblocksselected:=0;<br />
gotoAPA:=true;<br />
buttonreqchange;<br />
end;<br />
procedure TAPA_Selection_Screen.Button_delete_allClick(Sender: TObject);<br />
begin<br />
APA_Dialog.APA_Text.Caption:='Are you sure to erase all cubes in the APA Selection<br />
Screen and in the APA itself?';<br />
if APA_Dialog.showmodal=mryes then begin<br />
end;<br />
zellezeile:=0;<br />
while (zellezeile
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
end.<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
12.1.32 UNIT APA_SHOW_COSTSUNIT.DFM<br />
object APA_Showcosts: TAPA_Showcosts<br />
Left = 220<br />
Top = 114<br />
Width = 696<br />
Height = 480<br />
Caption = 'Show Costs'<br />
Color = clBtnFace<br />
Font.Charset = DEFAULT_CHARSET<br />
Font.Color = clWindowText<br />
Font.Height = -11<br />
Font.Name = 'MS Sans Serif'<br />
Font.Style = []<br />
OldCreateOrder = False<br />
Position = poScreenCenter<br />
OnClose = FormClose<br />
OnShow = FormShow<br />
PixelsPerInch = 96<br />
TextHeight = 13<br />
object Panel1: TPanel<br />
Left = 0<br />
Top = 0<br />
Width = 688<br />
Height = 41<br />
Align = alTop<br />
TabOrder = 0<br />
object Button2: TButton<br />
Left = 16<br />
Top = 8<br />
Width = 89<br />
Height = 25<br />
Caption = 'Export to Excel'<br />
TabOrder = 0<br />
OnClick = Button2Click<br />
end<br />
end<br />
object Panel2: TPanel<br />
Left = 0<br />
Top = 405<br />
Width = 688<br />
Height = 41<br />
Align = alBottom<br />
TabOrder = 1<br />
object Button1: TButton<br />
Left = 16<br />
Top = 8<br />
Width = 75<br />
Height = 25<br />
Cancel = True<br />
Caption = 'Close && Save'<br />
TabOrder = 0<br />
OnClick = Button1Click<br />
end<br />
object Button3: TButton<br />
Left = 104<br />
Top = 8<br />
Width = 75<br />
Height = 25<br />
Caption = 'Abort'<br />
TabOrder = 1<br />
OnClick = Button3Click<br />
end<br />
end<br />
object Kostengriddat: TStringGrid<br />
Left = 0<br />
Top = 41<br />
Width = 688<br />
Height = 364<br />
Align = alClient<br />
- 458 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
ColCount = 7<br />
DefaultColWidth = 60<br />
DefaultRowHeight = 20<br />
Options = [goFixedVertLine, goFixedHorzLine, goVertLine, goHorzLine, goRangeSelect,<br />
goColSizing, goEditing]<br />
TabOrder = 2<br />
OnGetEditMask = KostengriddatGetEditMask<br />
OnSetEditText = KostengriddatSetEditText<br />
end<br />
object OpenDialogcosts: TOpenDialog<br />
DefaultExt = 'xls'<br />
Filter = 'Excel Files|*.xls'<br />
Left = 376<br />
Top = 224<br />
end<br />
end<br />
12.1.33 UNIT APA_SHOW_COSTSUNIT.PAS<br />
unit APA_Show_costsunit;<br />
interface<br />
uses<br />
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,<br />
Dialogs, StdCtrls, Grids, ExtCtrls, ComObj;<br />
type<br />
TAPA_Showcosts = class(TForm)<br />
Panel1: TPanel;<br />
Panel2: TPanel;<br />
Button2: TButton;<br />
OpenDialogcosts: TOpenDialog;<br />
Kostengriddat: TStringGrid;<br />
Button1: TButton;<br />
Button3: TButton;<br />
procedure Button1Click(Sender: TObject);<br />
procedure FormShow(Sender: TObject);<br />
procedure FormClose(Sender: TObject; var Action: TCloseAction);<br />
procedure Button2Click(Sender: TObject);<br />
procedure KostengriddatSetEditText(Sender: TObject; ACol,<br />
ARow: Integer; const Value: String);<br />
procedure KostengriddatGetEditMask(Sender: TObject; ACol,<br />
ARow: Integer; var Value: String);<br />
procedure Button3Click(Sender: TObject);<br />
private<br />
{ Private-Deklarationen }<br />
public<br />
{ Public-Deklarationen }<br />
end;<br />
var<br />
APA_Showcosts: TAPA_Showcosts;<br />
implementation<br />
uses APA_Applicationunit;<br />
{$R *.dfm}<br />
var wurdebearbeitet:boolean;<br />
procedure TAPA_Showcosts.Button1Click(Sender: TObject);<br />
begin<br />
Close;<br />
end;<br />
procedure TAPA_Showcosts.FormShow(Sender: TObject);<br />
var counter:longint;<br />
var zeile:longint;<br />
begin<br />
wurdebearbeitet:=false;<br />
- 459 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');<br />
reset(fKosten);<br />
try<br />
Kostengriddat.Cells[1,0]:='FromColumn';<br />
Kostengriddat.Cells[2,0]:='FromRow';<br />
Kostengriddat.Cells[3,0]:='ToColumn';<br />
Kostengriddat.Cells[4,0]:='ToRow';<br />
Kostengriddat.Cells[5,0]:='Query';<br />
Kostengriddat.Cells[6,0]:='Build';<br />
counter:=filesize(fKosten);<br />
Kostengriddat.RowCount:=counter-1;<br />
Kostengriddat.ColWidths[0]:=25;<br />
zeile:=0;<br />
while zeile
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
vKosten.VonSpalte:=strtoint(trim(Kostengriddat.Cells[1,zeile]));<br />
vKosten.VonZeile:=strtoint(trim(Kostengriddat.Cells[2,zeile]));<br />
vKosten.ZuSpalte:=strtoint(trim(Kostengriddat.Cells[3,zeile]));<br />
vKosten.ZuZeile:=strtoint(trim(Kostengriddat.Cells[4,zeile]));<br />
vKosten.Query:=strtoint(trim(Kostengriddat.Cells[5,zeile]));<br />
vKosten.Build:=strtoint(trim(Kostengriddat.Cells[6,zeile]));<br />
write(fKosten,vKosten);<br />
end;<br />
end;<br />
finally<br />
CloseFile(fKosten);<br />
end;<br />
end;<br />
end;<br />
procedure TAPA_Showcosts.Button2Click(Sender: TObject);<br />
var zeile : Integer;<br />
var Excel : variant;<br />
var counter:longint;<br />
begin<br />
try<br />
assignfile(fKosten,'c:\APADIR\DATA\Kosten.dat');<br />
reset(fKosten);<br />
try<br />
if opendialogcosts.Execute then begin<br />
try<br />
try<br />
Excel := GetactiveOleObject('Excel.Application');<br />
except<br />
try<br />
Excel := CreateOleObject('Excel.Application');<br />
try<br />
Excel.Workbooks.Open (Filename:=opendialogcosts.filename);<br />
except<br />
Excel.Workbooks.add;<br />
Excel.ActiveWorkbook.SaveAs (Filename:=Opendialogcosts.filename);<br />
end;<br />
except<br />
ShowMessage('Excel konnte nicht gestartet werden !');<br />
Exit;<br />
end;<br />
end;<br />
counter:=0;<br />
Excel.Visible := false; { für die testphase sinnvoll }<br />
Excel.sheets[1].select;<br />
Excel.sheets.add;<br />
Excel.sheets[1].Name := 'Export';<br />
zeile:=1;<br />
application.ProcessMessages;<br />
{Überschriften}<br />
Excel.Cells[zeile, 1].Value := 'FromColumn';<br />
Excel.Cells[zeile, 2].Value := 'FromRow';<br />
Excel.Cells[zeile, 3].Value := 'ToColumn';<br />
Excel.Cells[zeile, 4].Value := 'ToRow';<br />
Excel.Cells[zeile, 5].Value := 'Query';<br />
Excel.Cells[zeile, 6].Value := 'Build';<br />
application.ProcessMessages;<br />
repeat;<br />
zeile:=zeile+1;<br />
counter:=counter+1;<br />
if counter
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
seek(fKosten,counter);<br />
read(fKosten,vKosten);<br />
application.ProcessMessages;<br />
Excel.Cells[zeile, 1].Value := vKosten.VonSpalte;<br />
Excel.Cells[zeile, 2].Value := vKosten.VonZeile;<br />
Excel.Cells[zeile, 3].Value := vKosten.ZuSpalte;<br />
Excel.Cells[zeile, 4].Value := vKosten.ZuZeile;<br />
Excel.Cells[zeile, 5].Value := vKosten.Query;<br />
Excel.Cells[zeile, 6].Value := vKosten.Build;<br />
application.ProcessMessages;<br />
end;<br />
until (counter>=filesize(fKosten));<br />
Application.BringToFront;<br />
showmessage('Data saved');<br />
finally<br />
Excel.visible:=true;<br />
Application.BringToFront;<br />
Excel.Visible := false; Excel.visible:=true;<br />
Excel.workbooks.Close;<br />
end;<br />
end;{opendialog1}<br />
finally<br />
end;<br />
finally<br />
CloseFile(fKosten);<br />
end;<br />
end;<br />
procedure TAPA_Showcosts.KostengriddatSetEditText(Sender: TObject; ACol,<br />
ARow: Integer; const Value: String);<br />
begin<br />
wurdebearbeitet:=true;<br />
end;<br />
procedure TAPA_Showcosts.KostengriddatGetEditMask(Sender: TObject; ACol,<br />
ARow: Integer; var Value: String);<br />
begin<br />
Value := '!000000000;1';<br />
end;<br />
procedure TAPA_Showcosts.Button3Click(Sender: TObject);<br />
begin<br />
wurdebearbeitet:=false;<br />
Close;<br />
end;<br />
end.<br />
12.1.34 UNIT APA_SQLUNIT.DFM<br />
object APA_Sql: TAPA_Sql<br />
Left = 220<br />
Top = 114<br />
Width = 696<br />
Height = 480<br />
Caption = 'APA Sql Scripts'<br />
Color = clBtnFace<br />
Font.Charset = DEFAULT_CHARSET<br />
- 462 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Font.Color = clWindowText<br />
Font.Height = -11<br />
Font.Name = 'MS Sans Serif'<br />
Font.Style = []<br />
OldCreateOrder = False<br />
Position = poScreenCenter<br />
PixelsPerInch = 96<br />
TextHeight = 13<br />
object Panel1: TPanel<br />
Left = 0<br />
Top = 400<br />
Width = 688<br />
Height = 46<br />
Align = alBottom<br />
TabOrder = 0<br />
object Button1: TButton<br />
Left = 306<br />
Top = 10<br />
Width = 75<br />
Height = 25<br />
Cancel = True<br />
Caption = 'Close'<br />
TabOrder = 0<br />
OnClick = Button1Click<br />
end<br />
end<br />
object SQLtext: TRichEdit<br />
Left = 0<br />
Top = 41<br />
Width = 688<br />
Height = 359<br />
Align = alClient<br />
ScrollBars = ssBoth<br />
TabOrder = 1<br />
end<br />
object Panel2: TPanel<br />
Left = 0<br />
Top = 0<br />
Width = 688<br />
Height = 41<br />
Align = alTop<br />
TabOrder = 2<br />
object Button2: TButton<br />
Left = 16<br />
Top = 8<br />
Width = 121<br />
Height = 25<br />
Caption = 'Save SQL Script'<br />
TabOrder = 0<br />
OnClick = Button2Click<br />
end<br />
end<br />
object SaveDialogsql: TSaveDialog<br />
DefaultExt = 'SQL'<br />
Filter = 'SQL Script|*.sql'<br />
Left = 264<br />
Top = 144<br />
end<br />
end<br />
12.1.35 UNIT APA_SQLUNIT.PAS<br />
unit APA_Sqlunit;<br />
interface<br />
uses<br />
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,<br />
Dialogs, StdCtrls, ExtCtrls, ComCtrls;<br />
type<br />
TAPA_Sql = class(TForm)<br />
- 463 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Panel1: TPanel;<br />
Button1: TButton;<br />
SQLtext: TRichEdit;<br />
Panel2: TPanel;<br />
Button2: TButton;<br />
SaveDialogsql: TSaveDialog;<br />
procedure Button1Click(Sender: TObject);<br />
procedure Button2Click(Sender: TObject);<br />
private<br />
{ Private-Deklarationen }<br />
public<br />
{ Public-Deklarationen }<br />
end;<br />
var<br />
APA_Sql: TAPA_Sql;<br />
implementation<br />
uses APA_Optionsunit;<br />
{$R *.dfm}<br />
procedure TAPA_Sql.Button1Click(Sender: TObject);<br />
begin<br />
Close;<br />
end;<br />
procedure TAPA_Sql.Button2Click(Sender: TObject);<br />
var SaveFile:TextFile;<br />
var zahler:longint;<br />
begin<br />
Savedialogsql.InitialDir:=APA_Options.APA_Save_Path.Directory;<br />
if savedialogsql.Execute then begin<br />
AssignFile(SaveFile,Savedialogsql.FileName);<br />
{$I-}<br />
Rewrite(SaveFile);<br />
{$I+}<br />
if IOResult = 0 then<br />
begin<br />
end;<br />
end;<br />
end.<br />
for zahler:=0 to Sqltext.lines.count-1 do begin<br />
writeln(SaveFile,SQLtext.lines[zahler]);<br />
end;<br />
CloseFile(SaveFile);<br />
end<br />
else<br />
MessageDlg('File access error', mtWarning, [mbOk], 0);<br />
12.2 QUELLCODES DER HILFEDATEIEN<br />
12.2.1 INDEX.HTM<br />
<br />
<br />
<br />
<br />
Willkommen<br />
<br />
<br />
- 464 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
<br />
<br />
<br />
Welcome to the APA Helpfile Website. This site should help you working with<br />
the APA program developed by Thomas Achs 2004. Use the Links above to navigate<br />
to special help topics.<br />
The APA (Aggregation Path Array) is a semi-graphical data modelling method in a data<br />
warehouse.<br />
This programm helps you to<br />
<br />
paint the APA <br />
show the redundancy-free set <br />
get the required cubes marked in the set <br />
see the derivatives of one cube <br />
see the sum of the derivatives of many cubes <br />
compare the required cubes and the materialized cubes <br />
calculate the materialized cubes with Thomas Achs heuristic<br />
<br />
<br />
<br />
<br />
12.2.2 APA_GRID_SCREEN.HTM<br />
<br />
<br />
<br />
<br />
APA Help - APA Grid<br />
<br />
<br />
<br />
<br />
<br />
<br />
The APA Grid Screen shows the APA. This screen offers a lot of functions and<br />
useful operations.<br />
<br />
TOPICS<br />
Show descriptions of cubes<br />
Show short description<br />
Show long description<br />
Required cubes<br />
Add required cubes<br />
Remove required cube<br />
Remove all required cubes<br />
Materialized cubes<br />
Add materialized cube<br />
Remove materialized cube<br />
Remove all materialized cubes<br />
Derivates<br />
Show derivates<br />
Remove derivates<br />
Redundant cubes<br />
Show redundancy free cubes<br />
Heuristik<br />
Generate materialized cubes<br />
Permutation<br />
Find deterministic<br />
solution by permutation<br />
Combination<br />
Find deterministic<br />
solution by combination<br />
Deterministic solution<br />
Show deterministic solution<br />
- 465 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
Remove deterministic solution<br />
Possible cubes<br />
Show possible cubes<br />
Remove possible cubes<br />
Build SQL Statements<br />
Build SQL statements for star<br />
schema<br />
Build SQL<br />
statements for fact constellation schema<br />
Get Query of cube<br />
Save SQL Script<br />
Use Random Costs<br />
Set use random costs<br />
<br />
Show short description<br />
In order to get the detailed description of a cube move the mouse over the<br />
cell and see the short description in the status bar above.<br />
<br />
Show long description<br />
To get the right long description of a cube click the cell with the left<br />
mouse button.<br />
<br />
Add required cubes<br />
In order to add a required cube move to the cell and press the right mouse<br />
button. Choose required and the right importance.<br />
<br />
<br />
Remove required cube<br />
In order to remove a required cube select the cube an press the right mouse<br />
button and select "Not required".<br />
<br />
Remove all required cubes<br />
<br />
Add materialized cube<br />
<br />
<br />
Remove materialized cube<br />
<br />
Remove all materialized cubes<br />
In order to remove all materialized cubes press the button "Remove<br />
materialized cubes".<br />
<br />
Show derivatives<br />
In order to show a derivatives of a cube select the cube and press the right<br />
mouse button and select "Show derivatives".<br />
<br />
<br />
Remove derivatives<br />
In order to remove the derivatives press the button "Remove<br />
derivatives".<br />
<br />
Show redundancy free cubes<br />
If you want to remove the redundant cubes of the APA tick "Remove<br />
redundancy".<br />
<br />
Generate materialized cubes<br />
After you have selected all your required cubes the Thomas ACHS heuristc,<br />
will calculate the right cubes, which should be materialized.<br />
<br />
Select "Search using Thomas Achs heuristic" in the menu and the<br />
cubes will be selected.<br />
<br />
<br />
The Screen below shows the calculated set of materialized cubes.<br />
<br />
Find deterministic<br />
solution by permutation<br />
In oder to proof the heuristic the deterministic solution must be calculated.<br />
If you want to do that by permutation select "Alogirthm permutation"<br />
in the menu.<br />
<br />
<br />
<br />
Find deterministic<br />
- 466 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
solution by combination<br />
In oder to proof the heuristic the deterministic solution must be calculated.<br />
If you want to do that by combination select "Alogirthm combitation"<br />
in the menu.<br />
<br />
<br />
<br />
Show deterministic solution<br />
To have a look at the deterministic solution press "Show deterministic<br />
solution".<br />
<br />
<br />
Remove deterministic solution<br />
In order to remove the deterministic solution press "Remove<br />
deterministic solution".<br />
<br />
Show possible cubes<br />
If you want to see the set of possible cubes press "Show possible<br />
cubes".<br />
<br />
<br />
<br />
Remove possible cubes<br />
If you want to remove the set of possible cubes press "Remove possible<br />
cubes".<br />
<br />
Build SQL statements for star<br />
schema<br />
In order to create the SQL Statements for the star schema select "Generate<br />
CREATE SQL-statements for star schema- Generate CREATE SQL-statements BFT and<br />
dimension tables".<br />
<br />
<br />
Build SQL<br />
statements for fact constellation schema<br />
In order to create the SQL Statements for the star schema select "Generate<br />
CREATE SQL-statements for fact constellation schema- Generate CREATE<br />
SQL-statements BFT and dimension tables". If you want to create the<br />
SQL-statements for the aggregated fact tables select "Generate CREATE<br />
SQL-statements for fact constellation schema- Generate CREATE SQL-statements for<br />
materialized cubes".<br />
<br />
<br />
Get Query of cube<br />
If you want to know the query of a cube select the cube, press right mouse<br />
button and select "Get SQL statement to query this cube".<br />
<br />
<br />
Save SQL Script<br />
If you want to save a SQL script press the button "Save SQL Script"<br />
and choose the name.<br />
<br />
<br />
Set use random costs<br />
If you want to calculate with random costs or not chosse "Use random<br />
costs" in Settings menu.<br />
<br />
<br />
12.2.3 APA_INPUT_SCREEN.HTM<br />
<br />
<br />
<br />
<br />
APA Help - APA Input Screen<br />
<br />
<br />
<br />
- 467 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
<br />
<br />
The APA Input Screen helps you to insert all<br />
the dimensions,<br />
hierarchies and key figures.<br />
Insert a dimension<br />
Insert a hierarchy level<br />
Change a dimension<br />
Change a hierarchy level<br />
Delete a dimension or hierarchy level<br />
Insert key figure<br />
Edit key figure<br />
Delete key figure<br />
<br />
Go to Top<br />
<br />
Insert a dimension<br />
To add a dimension press the button "Insert dimension" and the<br />
Insert-dimension-screen will open.<br />
<br />
Type the description of the new dimension in the "Dimension description"<br />
textfield and press "OK".<br />
<br />
The new dimension will be added to your "Input Screen".<br />
<br />
Go to Top<br />
Insert hierarchy<br />
To add a new hierarchy select the dimension you want to add the new hierarchy<br />
and press the Button "Insert hierarchy".<br />
<br />
Type your data into the textfields and press "OK".<br />
<br />
The hierarchy will be added to your dimension in the "Input<br />
Screen". It´s possible to change the order of the hierarchies by using the<br />
"Up" and "Down" buttons on the left.<br />
<br />
Go to Top<br />
Change a dimension<br />
To change a dimension select the dimension in the "Input Screen"<br />
and press the button "Edit".<br />
<br />
Change the description of the dimension and press "OK".<br />
<br />
The new description of the dimension will be changed in the "Input<br />
Screen".<br />
<br />
Go to Top<br />
Change a hierarchy<br />
To change a hierarchy select the hierarchy in the "Input Screen"<br />
and press the button "Edit".<br />
<br />
Type in the changed data and press the button "OK".<br />
<br />
The hierarchy will be changed in the "Input Screen".<br />
<br />
Go to Top<br />
Delete a dimension or<br />
hierarchy level<br />
Select the dimension or hierarchy level and press the button "Delete".<br />
<br />
The dimension or hierarchy level will be erased from the "Input<br />
Screen".<br />
<br />
Go to Top<br />
Insert a key figure<br />
In order to insert a key figure press the Button "Insert".<br />
<br />
Enter data into the "APA Insert Key" form and press "OK".<br />
<br />
<br />
Go to Top<br />
<br />
Edit a key figure<br />
- 468 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
In order to edit a key figure select the figure and press the button<br />
"Edit".<br />
<br />
Change data in the "APA Insert Key" form and press "OK".<br />
<br />
<br />
Go to Top<br />
<br />
Delete a key figure<br />
In order to delete a key figure please select the figure and press the Button<br />
"Delete".<br />
<br />
<br />
Go to Top<br />
<br />
<br />
<br />
12.2.4 APA_INSTALL.HTM<br />
<br />
<br />
<br />
<br />
Installation<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
How to install the APAWin<br />
program<br />
<br />
Valid for: APAWin Version 1<br />
Date: <br />
<br />
OVERWIEW<br />
This guide helps you install the APA program. There are two setup procedures<br />
nessesary to install the APA programm. First the database driver must be<br />
installed. You need administrator rights on your computer to run the setup.<br />
Second the APA program need to be installed. The setup programm installs all<br />
files required in the folder 'C:\APADIR'. Do not changed the name of the folder.<br />
This chause problems in running the software.<br />
<br />
HOW TO GO<br />
<br />
<strong>Download</strong> the SETUP.exe file to your computer and start the setup.<br />
<br />
<br />
The Setup program will start. The press "Weiter".<br />
<br />
<br />
Please wait a few seconds...<br />
<br />
<br />
- 469 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
<br />
The installation finished.<br />
<br />
<br />
<br />
<br />
<br />
<br />
12.2.5 APA_MAINMENU.HTM<br />
<br />
<br />
<br />
<br />
APA Help - APA Mainmenu<br />
<br />
<br />
<br />
<br />
<br />
<br />
The APA Main menu helps you to load and save your data, manipulate random<br />
costs, analyse the APA, edit the settings and show the help menu.<br />
Generate APA<br />
Selection Screen<br />
Mainmenu - File<br />
Load File<br />
Save File<br />
Save as.. File<br />
Mainmenu - Random costs<br />
Build random costs<br />
Show random costs<br />
Restricted costs<br />
Mainmenu-Analyse<br />
Analyse APA<br />
<br />
Go to Top<br />
<br />
Generate APA<br />
In order to generate the APA and show the APA Screen press button "APA<br />
Grid".<br />
Show Selection Screen<br />
In order to switch to "APA Selection Screen" press button "APA<br />
Selection Screen".<br />
Load File<br />
To Load a File press "File-Open" and select your file.<br />
<br />
<br />
Go to Top<br />
Save File<br />
To save the file press "File-Save".<br />
<br />
Go to Top<br />
Save as File<br />
Select "File-Save as ..." and choose a new file name.<br />
<br />
<br />
Go to Top<br />
Build random costs<br />
In order to generate random costs press "Random costs-Build random<br />
costs".<br />
<br />
<br />
<br />
Go to Top<br />
Show Random Costs<br />
- 470 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
In order to show the random costs select "Random costs-Show random<br />
costs".<br />
<br />
It´s possible to edit the data and to export the data to Excel.<br />
<br />
Go to Top<br />
Restricted costs<br />
To change the ticker Restricted costs select "Random costs-Restricted<br />
costs":<br />
<br />
Go to Top<br />
APA Analyse<br />
To show the "APA Analyse" window select "Analyse-Analyse<br />
APA".<br />
<br />
<br />
Go to Top<br />
<br />
<br />
12.2.6 APA_SELECTION_SCREEN.HTM<br />
<br />
<br />
<br />
<br />
APA Help - APA Selection Screen<br />
<br />
<br />
<br />
<br />
<br />
<br />
The APA Selection Screen helps you to do block operations or/and requirement<br />
operations.<br />
Block operations<br />
Add new requirement block<br />
Edit requirement block<br />
Delete requirement block<br />
Select block<br />
Deselect block<br />
Select all<br />
Deselect all<br />
Delete all requirement<br />
blocks and cubes<br />
Requirements operations<br />
Add new requirement<br />
Edit requirement<br />
Delete requirement<br />
<br />
<br />
Add new requirement block<br />
In order to add a new requirement block press the button "New req.<br />
block" and enter the data. If you select "Add max. hierarchy level"<br />
the maximum of all hierarchy levels is added.<br />
<br />
<br />
<br />
Edit requirement block<br />
If you want to edit a requirement block select the block and press the button<br />
"Edit req. block".<br />
<br />
<br />
<br />
Go to Top<br />
Delete requirement block<br />
If you want to delete a requirement block select the block and press the<br />
- 471 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER<br />
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN<br />
button "Delete req. block".<br />
<br />
<br />
Go to Top<br />
Select block<br />
In order to select a requirement block for adding the block to the APA select<br />
the block and press the button "Select".<br />
<br />
<br />
Go to Top<br />
Deselect block<br />
If you want to deselect a requirement block press the button<br />
"Deselect".<br />
<br />
<br />
Go to Top<br />
Select all<br />
Press the Button "Select all" if you want to select all required<br />
blocks.<br />
<br />
<br />
Go to Top<br />
Deselect all<br />
Press the Button "Deselect all" if you want to deselect all<br />
required blocks.<br />
<br />
<br />
Go to Top<br />
Delete all requirement<br />
blocks and cubes<br />
In order to delete all requirement blocks and all required cubes in the APA<br />
press "Delete all requirement blocks and cubes".<br />
<br />
<br />
<br />
<br />
Go to Top<br />
Add new requirement<br />
If you want to add a new requirement to an existing block press<br />
"Insert".<br />
<br />
<br />
<br />
Go to Top<br />
Edit requirement<br />
If you want to edit a new requirement select the requirement and press<br />
"Edit".<br />
Then change the requirement and press "Accept".<br />
<br />
<br />
<br />
<br />
Go to Top<br />
Delete requirement<br />
If you want to delete a single requirement select the requirement and press<br />
then button "Delete".<br />
<br />
<br />
Go to Top<br />
<br />
- 472 -