Optimierung der materialisierten Sichten in einem

OPTIMIERUNG DER MATERIALISIERTEN
SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM
ÜBERNOMMENEN OPERATIVEN DATEN
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
INHALTSVERZEICHNIS:
1 EINFÜHRUNG ........................................................................16
1.1
ZIEL DER ARBEIT ............................................................................. 16
1.2
VORGEHENSWEISE ........................................................................... 16
2 DATENMODELLIERUNG ........................................................17
2.1
SEMANTISCHES DATENMODELL ........................................................ 17
2.1.1
ENTITÄTEN (ENTITIES) .......................................................................... 18
2.1.2
ENTITÄTSMENGEN (ENTITY SETS) ........................................................ 18
2.1.3
ATTRIBUTE UND SCHLÜSSEL .................................................................. 19
2.1.4
BEZIEHUNGEN (RELATIONSHIPS) .......................................................... 20
2.1.5
KARDINALITÄTEN VON BEZIEHUNGEN .................................................. 21
2.1.5.1
1-1 BEZIEHUNGEN........................................................................... 21
2.1.5.2
1-N BEZIEHUNGEN .......................................................................... 22
2.1.5.3
M-N BEZIEHUNGEN......................................................................... 22
2.1.5.4
DIE REKURSIVE BEZIEHUNG ........................................................ 22
2.2
LOGISCHES DATENMODELL .............................................................. 23
2.2.1
ALLGEMEINES ........................................................................................ 23
2.2.2
DATENMODELLE..................................................................................... 24
2.2.2.1
HIERARCHISCHES DATENMODELL.............................................. 24
2.2.2.2
NETZWERKDATENMODELL ........................................................... 25
2.2.2.3
RELATIONALES DATENMODELL ................................................... 25
2.2.2.4
OBJEKTORIENTIERTES DATENMODELL ..................................... 26
2.2.2.5
OBJEKTRELATIONALES DATENMODELL..................................... 27
2.2.3
ÜBERFÜHRUNG DES ER-MODELLS INS RELATIONALE MODELL .......... 27
2.2.3.1
DIE UMSETZUNG DER 1:1 BEZIEHUNG....................................... 29
2.2.3.2
DIE UMSETZUNG DER 1:N BEZIEHUNG ...................................... 30
2.2.3.3
DIE UMSETZUNG DER M:N BEZIEHUNG..................................... 30
-2-
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
2.2.3.4
2.3
DIE UMSETZUNG EINER REKURSIVEN BEZIEHUNG................. 31
PHYSISCHES DATENMODELL............................................................. 31
3 SQL UND DATENBANKEN ....................................................32
3.1
DATENBANKEN ................................................................................ 32
3.1.1
ENTWICKLUNGSGESCHICHTE DER DATENBANKSYSTEME .................... 32
3.1.2
BEGRIFFSDEFINITIONEN ........................................................................ 32
3.1.3
ANFORDERUNGEN EINES DATENBANKSYSTEMS .................................... 33
3.2
SQL ALS STANDARDISIERTE DATENBANKSPRACHE ............................. 34
3.2.1
GESCHICHTLICHES ................................................................................. 34
3.2.2
DAS RELATIONALE MODELL ................................................................. 36
3.2.2.1
RELATIONALE DATENSTRUKTUR ................................................. 36
3.2.2.1.1 DOMÄNEN:.................................................................................... 36
3.2.2.1.2 RELATIONEN: ............................................................................... 36
3.2.2.1.3 EIGENSCHAFTEN VON RELATIONEN ............................................ 37
3.2.2.2
RELATIONALE INTEGRITÄT ........................................................... 38
3.2.2.2.1 SCHLÜSSELKANDIDAT (CANDIDATE KEY).................................... 38
3.2.2.2.2 PRIMÄRSCHLÜSSEL (PRIMARY KEY)............................................ 38
3.2.2.2.3 FREMDSCHLÜSSEL (FOREIGN KEY).............................................. 38
3.2.2.2.4 ENTITÄTSINTEGRITÄT .................................................................. 38
3.2.2.2.5 REFERENZIELLE INTEGRITÄT (REFERENTIAL INTEGRITY) ........ 38
3.2.2.3
RELATIONALE DATENMANIPULATION ........................................ 39
3.2.2.4
NORMALFORMEN ............................................................................ 40
3.2.2.4.1 ERSTE NORMALFORM (1NF) ....................................................... 40
3.2.2.4.2 ZWEITE NORMALFORM (2NF)..................................................... 40
3.2.2.4.3 DRITTE NORMALFORM (3NF) ..................................................... 40
3.2.2.4.4 BOYCE-CODD-NORMALFORM (BCNF) ....................................... 41
3.2.2.4.5 VOR- UND NACHTEILE DER NORMALISIERUNG .......................... 41
3.2.2.5
SICHTEN (VIEWS) ............................................................................. 41
-3-
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
3.2.2.5.1 TERMINOLOGIE ............................................................................ 41
3.2.2.5.2 ZWECK VON SICHTEN .................................................................. 42
3.2.2.5.3 AKTUALISIERUNG VON SICHTEN ................................................. 42
SQL NACH DEM STANDARD SQL 99 ..................................................... 42
3.2.3
3.2.3.1
SQL ALS DDL..................................................................................... 43
3.2.3.1.1 ERZEUGEN VON DBMS-OBJEKTEN (CREATE)......................... 43
3.2.3.1.2 ÄNDERN VON DBMS-OBJEKTEN (ALTER)................................ 43
3.2.3.1.3 VERGABE VON RECHTEN (GRANT) ........................................... 44
3.2.3.1.4 ENTZIEHEN VON RECHTEN (REVOKE) ..................................... 44
3.2.3.2
SQL ALS DML .................................................................................... 44
3.2.3.2.1 DIE SELECT ABFRAGE............................................................... 44
3.2.3.2.2 DIE INSERT ANWEISUNG ........................................................... 45
3.2.3.2.3 DIE UPDATE ANWEISUNG ......................................................... 45
3.2.3.2.4 DIE DELETE ANWEISUNG .......................................................... 45
3.2.3.3
SQL ALS DCL..................................................................................... 45
4 ERP-SYSTEME ......................................................................46
5 DAS DATA WAREHOUSE ......................................................47
5.1
DAS KONZEPT DES DATA WAREHOUSE ............................................. 47
5.2
ARCHITEKTUR EINES DATAWAREHOUSE ............................................ 48
5.2.1
OPERATIVE DATEN ................................................................................ 49
5.2.2
EXTERNE DATENBANKEN....................................................................... 50
5.2.3
DIE METADATEN .................................................................................... 50
5.2.4
DIE DATENPUMPEN ................................................................................ 50
5.2.5
DER DATAWAREHOUSE MANAGER........................................................ 50
5.2.6
ZUGRIFFSWERKZEUGE FÜR DEN ENDBENUTZER................................... 50
5.2.6.1
WERKZEUGE FÜR BERICHTE UND ABFRAGEN ......................... 51
5.2.6.2
WERKZEUGE ZUR ENTWICKLUNG VON ANWENDUNGEN ....... 51
5.2.6.3
EXECUTIVE INFORMATION SYSTEM WERKZEUGE (EIS) .......... 51
-4-
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
5.2.6.4
DECISION SUPPORT SYSTEME (DSS)............................................ 52
5.2.6.5
ONLINE ANALYTICAL PROCESSING WERKZEUGE (OLAP) ....... 52
5.2.6.6
DATA MINING WERKZEUGE .......................................................... 52
5.3
OPERATIVE UND ANALYTISCHE DATEN .............................................. 53
5.4 AUFBAUEN UND AKTUALISIEREN EINES DATAWAREHOUSE AUS DEN
DATENQUELLEN ......................................................................................... 55
5.4.1
KLASSISCHE VORGEHENSWEISE BEIM AUFBAUEN UND AKTUALISIEREN
EINES DATAWAREHOUSE ........................................................................................ 55
5.4.2
NEUE ANSÄTZE FÜR DAS AUFBAUEN UND AKTUALISIEREN DER
MATERIALISIERTEN SICHTEN ................................................................................ 55
5.4.2.1
DER WHIPS PROTOTYP................................................................... 56
5.4.2.2
DER SUMMARY TABLE ANSATZ ..................................................... 58
5.4.2.3
DER MULTIPLE VIEW MAINTENANCE POLICIES ANSATZ ........ 59
5.5
INFORMATIONSFLÜSSE IN EINEM DATA WAREHOUSE ......................... 60
5.5.1
INFLOW ................................................................................................... 60
5.5.2
UPFLOW .................................................................................................. 61
5.5.3
DOWNFLOW ............................................................................................ 61
5.5.4
OUTFLOW ............................................................................................... 61
5.5.5
METAFLOW ............................................................................................ 61
5.6
PROBLEME IM DATA WAREHOUSE .................................................... 62
5.7
VORTEILE EINES DATAWAREHOUSE................................................... 63
5.8 ANFORDERUNGEN AN EIN DATENBANKSYSTEM FÜR EIN
DATAWAREHOUSE ...................................................................................... 64
5.9
DATA MARTS .................................................................................... 66
5.10
DIE MODELLIERUNG EINES DATAWAREHOUSE ............................... 67
5.10.1
MODELLTHEORIE ................................................................................... 67
5.10.2
ATTRIBUTE ............................................................................................. 68
5.10.3
DIMENSIONEN UND HIERARCHIEN ......................................................... 68
5.10.4
DIE DATENWÜRFEL ................................................................................ 69
-5-
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
5.10.5
OPERATOREN ......................................................................................... 70
5.10.6
SLICE AND DICE ..................................................................................... 71
5.10.7
NAVIGATION DURCH DEN DATENBESTAND............................................ 72
5.10.8
KONZEPTIONELLE ODER SEMANTISCHE MODELLIERUNG ................... 73
5.10.8.1
GRAPHISCHE MODELLIERUNG ................................................ 73
5.10.8.2
HALBGRAPHISCHE MODELLIERUNG ...................................... 75
5.10.8.2.1 GITTER ....................................................................................... 75
5.10.8.2.2 AGGREGATION PATH ARRAY .................................................... 76
5.10.9
LOGISCHE UND PHYSIKALISCHE MODELLIERUNG ............................... 76
5.10.9.1
STAR-SCHEMA .............................................................................. 76
5.10.9.2
FACT CONSTELLATION-SCHEMA.............................................. 78
5.10.9.3
SNOWFLAKE-SCHEMA ................................................................ 79
5.10.9.4
GALAXY-SCHEMA......................................................................... 80
5.10.9.5
DAS UNIMU-SCHEMA.................................................................. 81
6 DIE MODELLIERUNGSMETHODE AGGREGATION PATH
ARRAY.........................................................................................83
7 FORSCHUNGSSCHWERPUNKT UND ERGEBNISSE ................90
7.1
DAS GRUNDPROBLEM UND DER LÖSUNGSANSATZ ............................. 90
7.2
DIE VORGEHENSWEISE..................................................................... 91
7.3
ABGRENZUNG DER PHASEN DER BETRACHTUNG................................ 92
7.4
VERWANDTE ALGORITHMEN IM PROBLEMZUSAMMENHANG ............... 94
7.4.1
KÜRZESTE UND LÄNGSTE WEGE ............................................................ 94
7.4.1.1
BEGRIFFSBESTIMMUNGEN ........................................................... 94
7.4.1.1.1 GRAPHEN ...................................................................................... 94
7.4.1.1.2 EINGANGS- UND AUSGANGSGRAD ............................................... 95
7.4.1.1.3 WEG, ZYKLUS .............................................................................. 95
7.4.1.1.4 KNOTEN- UND KANTENWERTE .................................................... 95
7.4.1.1.5 KLASSIFIZIERUNG VON GRAPHEN ................................................ 96
-6-
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.4.1.2 KÜRZESTE WEGE VON EINEM KONTEN IM GRAPHEN ZU
ALLEN ANDEREN ............................................................................................. 96
7.4.1.2.1 ALGORITHMUS VON DIJKSTRA .................................................... 97
7.4.1.2.2 ALGORITHMUS VON BELLMANN-FORD ..................................... 103
7.4.1.2.3 KÜRZESTE WEGE FÜR EINEN AZYKLISCHEN GRAPHEN ........... 104
7.4.1.3
KÜRZESTE WEGE ZWISCHEN ALLEN KONTEN IM GRAPHEN 106
7.5 KOSTENBASIERENDE ABFRAGEBEARBEITUNG IN RELATIONALEN
SYSTEMEN ................................................................................................ 108
7.6
DIE HEURISTIKEN .......................................................................... 116
7.6.1
EINTEILUNG DER KOSTEN.................................................................... 116
7.6.2
KOSTENSCHÄTZFUNKTION DER ABFRAGEPHASE................................ 117
7.6.2.1
BEGRIFFSDEFINITIONEN............................................................. 117
7.6.2.2
WERTEBEREICHE UND BEDINGUNGEN.................................... 118
7.6.2.3
FUNKTION....................................................................................... 118
7.6.2.4
BESCHREIBUNG DER KOSTENSCHÄTZFUNKTION .................. 118
7.6.3
KOSTENSCHÄTZFUNKTIONEN DER MATERIALISIERUNGSPHASE ........ 118
7.6.3.1
BEGRIFFSDEFINITIONEN............................................................. 118
7.6.3.2
WERTEBEREICHE UND BEDINGUNGEN.................................... 119
7.6.3.3
FUNKTION....................................................................................... 119
7.6.3.4
BESCHREIBUNG DER KOSTENSCHÄTZFUNKTION .................. 120
7.6.4
GESAMTKOSTEN ................................................................................... 120
7.6.4.1
BEGRIFFSDEFINITIONEN............................................................. 120
7.6.4.2
WERTEBEREICHE UND BEDINGUNGEN.................................... 121
7.6.4.3
FUNKTION....................................................................................... 121
7.6.5
ZUFÄLLIGE KOSTEN............................................................................. 121
7.6.6
HEURISTIK VON ALEXANDER PROSSER ........................................... 123
7.6.7
HEURISTIK VON THOMAS ACHS......................................................... 127
7.6.7.1
PSEUDOCODE DER HEURISTIK .................................................. 127
7.6.7.2
BESCHREIBUNG DER HEURISTIK............................................... 134
-7-
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.6.7.3
7.7
DEMONSTRATIVES BEISPIEL ....................................................... 134
DIE DETERMINISTISCHE LÖSUNG .................................................... 147
7.7.1
MATHEMATISCHE GRUNDLAGEN ........................................................ 147
7.7.1.1
PERMUTATION ............................................................................... 147
7.7.1.2
KOMBINATION................................................................................ 147
7.7.2
DER ALGORITHMUS FÜR DIE PERMUTATION ...................................... 148
7.7.3
DER ALGORITHMUS FÜR DIE KOMBINATION ...................................... 152
7.7.4
DER ALGORITHMUS DER FUNKTION GETRIGHTORDER .................... 156
7.7.5
DER ALGORITHMUS DER FUNKTION KOSTENFUERSETBERECHNEN. 161
7.8
DIE ENTWICKLUNGSUMGEBUNG UND DIE APPLIKATION .................. 164
7.8.1
AUSWAHL DER ENTWICKLUNGSUMGEBUNG ....................................... 164
7.8.2
ENTWURF DER BENUTZERSCHNITTSTELLE ......................................... 165
7.8.2.1
DAS HAUPTMENU.......................................................................... 165
7.8.2.2
DIE EINGABEMASKE (INPUT SCREEN) ...................................... 166
7.8.2.3
DIE PRÄSENTATIONSMASKE (APA SCREEN) ............................. 167
7.8.2.4 DIE AUSWAHLMASKE DER REQUIRED CUBES (SELECTION
SCREEN)168
DATENMODELLIERUNG DER APPLIKATION ......................................... 169
7.8.3
7.8.3.1
AUSWAHL DER DATENBANK........................................................ 169
7.8.3.2
SEMANTISCHE DATENMODELLIERUNG.................................... 170
7.8.3.3
LOGISCHE DATENMODELLIERUNG........................................... 173
7.8.3.4
PHYSISCHE DATENMODELLIERUNG ......................................... 176
7.8.3.4.1 FORMALE SQL-ANWEISUNGEN LAUT SQL 99 ......................... 176
7.8.3.4.2 MICROSOFT SQL SPEZIFISCHE SQL ANWEISUNGEN ............... 178
7.8.3.5 GENERIEREN DER CREATE TABLE ANWEISUNGEN IN DER
SOFTWARE ...................................................................................................... 184
7.8.3.5.1 DAS STAR-SCHEMA .................................................................... 184
7.8.3.5.2 DAS FACT CONSTELLATION SCHEMA ....................................... 186
7.8.3.5.3 BEISPIELHAFTES UMSETZEN DER TABLES DURCH DAS
PROGRAMM .................................................................................................. 187
-8-
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.8.3.5.3.1 DIE AUSGANGSPOSITION ........................................................ 187
7.8.3.5.3.2 DIE SCRIPTS FÜR DAS STAR SCHEMA ....................................... 189
7.8.3.5.3.3 DIE SCRIPTS FÜR DAS FACT CONSTELLATION SCHEMA ............ 193
7.9
ERGEBNISSE DER TESTS DER HEURISTIKEN ..................................... 200
7.9.1
PROBLEME BEI TESTEN DER HEURISTIK ............................................. 200
7.9.2
GESAMTÜBERSICHT ÜBER DIE ERGEBNISSE ........................................ 202
7.9.3
DIE ERGEBNISSE IM DETAIL ................................................................ 204
7.9.3.1
VORGABEN UND ERGEBNISSE TEST 1 ....................................... 204
7.9.3.1.1 VORGABEN.................................................................................. 204
7.9.3.1.2 LÖSUNG DER HEURISTIK............................................................ 204
7.9.3.1.3 DETERMINISTISCHE LÖSUNG ..................................................... 205
7.9.3.1.4 VERGLEICH DER ERGEBNISSE ................................................... 205
7.9.3.2
VORGABEN UND ERGEBNISSE TEST 2 ....................................... 205
7.9.3.2.1 VORGABEN.................................................................................. 205
7.9.3.2.2 LÖSUNG DER HEURISTIK............................................................ 206
7.9.3.2.3 DETERMINISTISCHE LÖSUNG ..................................................... 206
7.9.3.2.4 VERGLEICH DER ERGEBNISSE ................................................... 207
7.9.3.3
VORGABEN UND ERGEBNISSE TEST 3 ....................................... 207
7.9.3.3.1 VORGABEN.................................................................................. 207
7.9.3.3.2 LÖSUNG DER HEURISTIK............................................................ 207
7.9.3.3.3 DETERMINISTISCHE LÖSUNG ..................................................... 208
7.9.3.3.4 VERGLEICH DER ERGEBNISSE ................................................... 208
7.9.3.4
VORGABEN UND ERGEBNISSE TEST 4 ....................................... 209
7.9.3.4.1 VORGABEN.................................................................................. 209
7.9.3.4.2 LÖSUNG DER HEURISTIK............................................................ 209
7.9.3.4.3 DETERMINISTISCHE LÖSUNG ..................................................... 210
7.9.3.4.4 VERGLEICH DER ERGEBNISSE ................................................... 210
7.9.3.5
VORGABEN UND ERGEBNISSE TEST 5 ....................................... 211
7.9.3.5.1 VORGABEN.................................................................................. 211
-9-
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.5.2 LÖSUNG DER HEURISTIK............................................................ 211
7.9.3.5.3 DETERMINISTISCHE LÖSUNG ..................................................... 212
7.9.3.5.4 VERGLEICH DER ERGEBNISSE ................................................... 212
7.9.3.6
VORGABEN UND ERGEBNISSE TEST 6 ....................................... 213
7.9.3.6.1 VORGABEN.................................................................................. 213
7.9.3.6.2 LÖSUNG DER HEURISTIK............................................................ 213
7.9.3.6.3 DETERMINISTISCHE LÖSUNG ..................................................... 214
7.9.3.6.4 VERGLEICH DER ERGEBNISSE ................................................... 214
7.9.3.7
VORGABEN UND ERGEBNISSE TEST 7 ....................................... 215
7.9.3.7.1 VORGABEN.................................................................................. 215
7.9.3.7.2 LÖSUNG DER HEURISTIK............................................................ 215
7.9.3.7.3 DETERMINISTISCHE LÖSUNG ..................................................... 216
7.9.3.7.4 VERGLEICH DER ERGEBNISSE ................................................... 216
7.9.3.8
VORGABEN UND ERGEBNISSE TEST 8 ....................................... 217
7.9.3.8.1 VORGABEN.................................................................................. 217
7.9.3.8.2 LÖSUNG DER HEURISTIK............................................................ 217
7.9.3.8.3 DETERMINISTISCHE LÖSUNG ..................................................... 218
7.9.3.8.4 VERGLEICH DER ERGEBNISSE ................................................... 218
7.9.3.9
VORGABEN UND ERGEBNISSE TEST 9 ....................................... 219
7.9.3.9.1 VORGABEN.................................................................................. 219
7.9.3.9.2 LÖSUNG DER HEURISTIK............................................................ 219
7.9.3.9.3 DETERMINISTISCHE LÖSUNG ..................................................... 220
7.9.3.9.4 VERGLEICH DER ERGEBNISSE ................................................... 220
7.9.3.10
VORGABEN UND ERGEBNISSE TEST 10 ................................. 221
7.9.3.10.1 VORGABEN................................................................................ 221
7.9.3.10.2 LÖSUNG DER HEURISTIK.......................................................... 221
7.9.3.10.3 DETERMINISTISCHE LÖSUNG ................................................... 222
7.9.3.10.4 VERGLEICH DER ERGEBNISSE ................................................. 222
7.9.3.11
VORGABEN UND ERGEBNISSE TEST 11 ................................. 223
- 10 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.11.1 VORGABEN................................................................................ 223
7.9.3.11.2 LÖSUNG DER HEURISTIK.......................................................... 223
7.9.3.11.3 DETERMINISTISCHE LÖSUNG ................................................... 224
7.9.3.11.4 VERGLEICH DER ERGEBNISSE ................................................. 224
7.9.3.12
VORGABEN UND ERGEBNISSE TEST 12 ................................. 225
7.9.3.12.1 VORGABEN................................................................................ 225
7.9.3.12.2 LÖSUNG DER HEURISTIK.......................................................... 225
7.9.3.12.3 DETERMINISTISCHE LÖSUNG ................................................... 226
7.9.3.12.4 VERGLEICH DER ERGEBNISSE ................................................. 226
7.9.3.13
VORGABEN UND ERGEBNISSE TEST 13 ................................. 227
7.9.3.13.1 VORGABEN................................................................................ 227
7.9.3.13.2 LÖSUNG DER HEURISTIK.......................................................... 227
7.9.3.13.3 DETERMINISTISCHE LÖSUNG ................................................... 228
7.9.3.13.4 VERGLEICH DER ERGEBNISSE ................................................. 228
7.9.3.14
VORGABEN UND ERGEBNISSE TEST 14 ................................. 229
7.9.3.14.1 VORGABEN................................................................................ 229
7.9.3.14.2 LÖSUNG DER HEURISTIK.......................................................... 230
7.9.3.14.3 DETERMINISTISCHE LÖSUNG ................................................... 231
7.9.3.14.4 VERGLEICH DER ERGEBNISSE ................................................. 231
7.9.3.15
VORGABEN UND ERGEBNISSE TEST 15 ................................. 232
7.9.3.15.1 VORGABEN................................................................................ 232
7.9.3.15.2 LÖSUNG DER HEURISTIK.......................................................... 232
7.9.3.15.3 DETERMINISTISCHE LÖSUNG ................................................... 233
7.9.3.15.4 VERGLEICH DER ERGEBNISSE ................................................. 233
7.9.3.16
VORGABEN UND ERGEBNISSE TEST 16 ................................. 233
7.9.3.16.1 VORGABEN................................................................................ 233
7.9.3.16.2 LÖSUNG DER HEURISTIK.......................................................... 234
7.9.3.16.3 DETERMINISTISCHE LÖSUNG ................................................... 236
7.9.3.16.4 VERGLEICH DER ERGEBNISSE ................................................. 237
- 11 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.17
VORGABEN UND ERGEBNISSE TEST 17 ................................. 238
7.9.3.17.1 VORGABEN................................................................................ 238
7.9.3.17.2 LÖSUNG DER HEURISTIK.......................................................... 239
7.9.3.17.3 DETERMINISTISCHE LÖSUNG ................................................... 240
7.9.3.17.4 VERGLEICH DER ERGEBNISSE ................................................. 240
7.9.3.18
VORGABEN UND ERGEBNISSE TEST 18 ................................. 241
7.9.3.18.1 VORGABEN................................................................................ 241
7.9.3.18.2 LÖSUNG DER HEURISTIK.......................................................... 241
7.9.3.18.3 DETERMINISTISCHE LÖSUNG ................................................... 242
7.9.3.18.4 VERGLEICH DER ERGEBNISSE ................................................. 242
8 CONCLUSIO .........................................................................242
9 LITERATUR .........................................................................244
10
ABBILDUNGSVERZEICHNIS .............................................250
11
TABELLENVERZEICHNIS .................................................254
12
ANHANG ...........................................................................255
12.1
QUELLCODE DER ANWENDUNG................................................... 255
12.1.1
PROGRAMM QUELLCODE APAWIN ................................................... 255
12.1.2
UNIT APA_ANALYSEUNIT.DFM ........................................................... 255
12.1.3
UNIT APA_ANALYSEUNIT.PAS ............................................................ 256
12.1.4
UNIT APA_APPLICATIONUNIT.DFM .................................................... 259
12.1.5
UNIT APA_APPLICATIONUNIT.PAS ..................................................... 262
12.1.6
UNIT APA_DIALOGUNIT.DFM .............................................................. 282
12.1.7
ENDUNIT APA_DIALOGUNIT.PAS ......................................................... 282
12.1.8
UNIT APA_GRIDUNIT.DFM .................................................................. 283
12.1.9
UNIT APA_GRIDUNIT.PAS ................................................................... 292
12.1.10
UNIT APA_HELPUNIT.DFM.............................................................. 388
12.1.11
UNIT APA_HELPUNIT.PAS ............................................................... 389
12.1.12
UNIT APA_INPUT_DIMENSIONUNIT.DFM ....................................... 390
- 12 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
12.1.13
UNIT APA_INPUT_DIMENSIONUNIT.PAS......................................... 391
12.1.14
UNIT APA_INPUT_HIERARCHYUNIT.DFM ...................................... 392
12.1.15
UNIT APA_INPUT_HIERARCHYUNIT.PAS ....................................... 393
12.1.16
UNIT APA_INPUT_REQBLOCKUNIT.DFM ........................................ 395
12.1.17
UNIT APA_INPUT_REQBLOCKUNIT.PAS ......................................... 396
12.1.18
UNIT APA_INPUT_SCREENUNIT.DFM ............................................. 397
12.1.19
UNIT APA_INPUT_SCREENUNIT.PAS............................................... 401
12.1.20
UNIT APA_KEYUNIT.DFM ............................................................... 412
12.1.21
UNIT APA_KEYUNIT.PAS ................................................................ 413
12.1.22
UNIT APA_OPTIONSUNIT.DFM ........................................................ 414
12.1.23
UNIT APA_OPTIONSUNIT.PAS ......................................................... 416
12.1.24
UNIT APA_PARAMETERUNIT.DFM .................................................. 417
12.1.25
UNIT APA_PARAMETERUNIT.PAS ................................................... 425
12.1.26
UNIT APA_PROCESSUNIT.DFM ........................................................ 434
12.1.27
UNIT APA_PROCESSUNIT.PAS ......................................................... 435
12.1.28
UNIT APA_SCREENUNIT.DFM ......................................................... 437
12.1.29
UNIT APA_SCREENUNIT.PAS ........................................................... 438
12.1.30
UNIT APA_SELECTIONUNIT.DFM .................................................... 440
12.1.31
UNIT APA_SELECTIONUNIT.PAS ..................................................... 444
12.1.32
UNIT APA_SHOW_COSTSUNIT.DFM ................................................ 458
12.1.33
UNIT APA_SHOW_COSTSUNIT.PAS ................................................. 459
12.1.34
UNIT APA_SQLUNIT.DFM ................................................................ 462
12.1.35
UNIT APA_SQLUNIT.PAS ................................................................. 463
12.2
QUELLCODES DER HILFEDATEIEN ............................................... 464
12.2.1
INDEX.HTM ........................................................................................... 464
12.2.2
APA_GRID_SCREEN.HTM ................................................................... 465
12.2.3
APA_INPUT_SCREEN.HTM .................................................................. 467
12.2.4
APA_INSTALL.HTM ............................................................................. 469
12.2.5
APA_MAINMENU.HTM ........................................................................ 470
- 13 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
12.2.6
APA_SELECTION_SCREEN.HTM ......................................................... 471
- 14 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
VORWORT UND DANKSAGUNGEN:
Das Thema der Dissertation und das Verfassen einer Dissertation ist eine
zeitaufwendige Tätigkeit. Durch die vielen Stunden, welche man in diese Arbeit
investiert, wird unwillkürlich anderes vernachlässigt. Dies zieht sich vom beruflichen
bis in den privaten Bereich. Das heißt, dass man auf seinem Wege bis hin zum
Abschließen der Arbeit viele Menschen vernachlässigt. Ihnen gebührt Dank und
Anerkennung, da sie somit einen Teil zu dieser Arbeit beigetragen haben.
Dabei möchte ich mich besonders bei Professor Prosser bedanken. Wäre er nicht an
mich herangetreten, hätte ich das Doktoratsstudium gar nicht begonnen. Zusätzlich
danke ich ihm auch für seine Unterstützung und Hilfe beim Verfassen und für so
manchen hilfreichen Tipp oder Denkanstoß. Weiters muss natürlich auch erwähnt
werden, dass meine Arbeit auch unmittelbar auf die Arbeit von Professor Prosser und
Frau Ossimitz aufbaut.
Besonderer Dank gilt auch Professor Janko dafür, dass er die Zweitbeurteilung dieser
Arbeit übernommen hat. Denn es ist bei solch speziellen Themen nicht sehr einfach
einen Beurteiler zu finden.
Der wichtigste Mann, welcher einen enormen Anteil am Gelingen dieser Arbeit hat, ist
mein Großvater Georg ACHS, der mich jeden Tag auf das Neue motiviert hat und
darauf aufmerksam gemacht hat, täglich ein neues Puzzlesteinchen zum Vollenden der
Arbeit hinzuzufügen. Ohne ihn und seine täglichen Ermunterungen wäre diese Arbeit
nie vollendet worden. Sehr großer Dank gilt auch meinen Eltern, Gerlinde und Hans
Georg ACHS, welche mich beruflich entlasten konnten und mir zu jeder Zeit eine
Stütze gewesen sind. Ein besonderer Dank an dieser Stelle speziell meiner Mutter für
das fachmännische Korrekturlesen der Arbeit. Auch meine Großmütter, meine
Schwester, meine Großtanten, weitere Verwandte und Freunde will ich erwähnen und
mich zusätzlich entschuldigen, dass ich sie, auf Grund dieser Arbeit, des Öfteren
versetzt und vernachlässigt habe. Ich werde mich bessern.
Thomas ACHS, Gols im JUNI 2004
- 15 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
1 EINFÜHRUNG
1.1 ZIEL DER ARBEIT
Das Planen und Entwickeln eines optimalen Data Warehouse-Systems ist ein Ansinnen
vieler Wissenschaftler und Forscher aus unterschiedlichen Bereichen. Zahlreiche
Publikationen wurden zu diesem Thema verfasst und in den letzten Jahren
veröffentlicht. In dieser Literatur wird versucht eine Heuristik zu entwickeln, welche
eine Lösung nahe am Optimum für das Materialisierungsproblem im Datawarehouse
liefert. In der Vergangenheit wurde in zahlreichen Publikationen Annahmen, wie
unbegrenzte Ressourcen oder rasche Zugriffszeit getroffen, welche in der realen Welt
allerdings nicht vorhanden sind. Die Vision, welche hinter dieser Arbeit steckt, ist es,
ein Instrument zu entwickeln, welches diese limitierenden Faktoren mitberücksichtigt,
bzw. dieses versucht. Dabei hat sich insbesonders die Modellierungsmethode des
Aggregation Path Arrays von Prosser und Ossimitz [vgl. Prosser/Ossimitz (2001)] als
geeignet erwiesen, in diesem Problembereich einen Lösungsansatz zu finden. Vor allem
ist diese Methode durch die einfache graphische Darstellungsfähigkeit besonders für
informationstechnische Darstellung geeignet. Dabei ist es auch unerfahrenen
Endbenutzer möglich, das Design eines Warehouses zu bewerkstelligen. Aus diesem
Grund ist die Methode auch für Schulungs- und Ausbildungszwecke besonders
geeignet.
Die kostenminimale physische Bereitstellung der wichtigen Informationen für die
Entscheidungsträger in Unternehmen stellt das Ziel dieser Arbeit dar. Dabei ist ein
Optimierungsproblem zu lösen, welches limitierende Zeit- und Speicherressourcen bei
gleichzeitigem Berücksichtigen wichtiger Information beachtet. Leider ist diese
Information nicht immer als homogen anzusehen. Es gibt beispielsweise wichtige
Information, welche für das Überleben einer Organisation notwendig ist und
Information, welche wichtig, aber nicht ständig verfügbar sein muss. Der Versuch einen
Lösungsansatz für diese Problematik zu finden, stellt das Herzstück meiner Arbeit dar.
1.2 VORGEHENSWEISE
Der Kern der Arbeit stellt das praktische Darstellen des Aggregation Path Arrays (APA)
dar. Dabei wird eine Software-Applikation (Quellcode im Anhang) ausprogrammiert,
welche ein benutzerunterstützendes Design des Data Warehouses ermöglicht. Zusätzlich
soll nach der Eingabe der benötigten Informationen, welche sich durch so genannte
„Required cubes“ manifestieren, der Benutzer bei der Auswahl der zu
materialisierenden und somit physisch in der Datenbank lagernden Information
- 16 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
unterstützt werden. Dies soll, da die Optimierung ein sehr komplexes Lösungsproblem
darstellen kann, heuristisch gelöst werden. Im Vergleich dazu werden Algorithmen
ausgetestet, welche zwar eine ideale Lösung liefern, aber für komplexe
Problemstellungen sehr lange Berechnungszeiten erfordern. Abschließend werden die
Ergebnisse verglichen, um eine Bewertung des heuristischen Ansatzes zu treffen.
Im Vorfeld wird relevante Literatur zum Konnex aufbereitet, welche die Grundlage zum
Verstehen der Zusammenhänge darstellt.
2 DATENMODELLIERUNG
Für die Modellierung von Daten ist es zweckmäßig, sich die verschiedenen
Betrachtungsebenen für Daten und Informationen zu veranschaulichen. Dabei versucht
man eine betriebswirtschaftliche Problemstellung in mehreren Stufen abzubilden.
Diese sind das
•
Fachkonzept (semantisches Datenmodell): Auf dieser Ebene befindet sich die
ER-Diagramm-Ebene.
•
DV-Konzept (logisches Datenmodell): Dies beschreibt die Daten eines
Informationssystems auf der Ebene der Datenbanken.
•
Technische Implementierung (physisches Datenmodell): Auf dieser Ebene
betrachtet man die reale Ausbildung der Datenbank, wie die SQL-Anweisungen.
Wie durch den hierarchischen Aufbau angedeutet werde ich mich bei meinen
Ausführungen vom semantischen Modell bis zur endgültigen Implementierung der
Datenbank und der Tables (Tabellen) vortasten.
2.1 SEMANTISCHES DATENMODELL
Ein vielfach bewährtes Werkzeug zur Erstellung von relationalen Datenbanken ist das
Entity Relationship Modell, kurz ER-Modell genannt. Dieses Modell wurde von P.
Chen im Jahre 1976 vorgestellt. Das ER-Modell verhindert Redundanzen bis auf
Fremdschlüssel auch relationenübergreifend. [vgl. Schicker (1999) S.136f ]
Um mit dem ER-Modell nach Chen arbeiten zu können sind im Vorfeld eine Reihe von
Begriffen zu klären und auszuformulieren. Diese Vokabel werden bei der Modellierung
verwendet und können als Bausteine für das ER-Diagramm angesehen werden. Wir
werden das ER-Modell für unsere Arbeit einsetzen. Deshalb soll es auch hier im Detail
erläutert werden. Alternative Modellierungsmethoden sind insbesondere das „ERModell nach der Notation „Barker“ oder die „Unified Modeling Language“ [vgl. Cordts
(2002) S. 35ff]. Für detaillierte weiterführende Ausführungen über semantische
- 17 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Datenmodellierung verweise ich auf Baldi (1999) S. 76ff, Fischer et al. (2000) S. 105ff,
Janko (1998) S. 335ff, Kemper (1999), S. 33ff und Meier (2001) S. 16ff.
2.1.1 ENTITÄTEN (ENTITIES)
Wie der Name schon sagt, ist der grundlegendste Baustein des ER-Diagramms die
Entität (Gegenstand). Entitäten sind wohlunterscheidbare physisch oder gedanklich
existierende Konzepte der zu modellierenden Welt. Entitäten werden im Diagramm
durch Rechtecke dargestellt.
Abbildung 1: Symbol für Entitätstyp
Man unterscheidet folgende Arten von Entitätstypen:
Super- und Subentitätstypen:
Superentitätstypen fassen gemeinsame Attributsmengen von Subentitätstypen
zusammen. Offensichtlich ist der Entitätstyp „Auftrag“ ein Superentitätstyp, da er
Attribute der Subentitätstypen „Kundenauftrag“, „Fertigungsauftrag“,
„Beschaffungsauftrag“ usw. zusammenfasst. Siehe dazu auch Entitätsmengen 2.1.2.
Fundamentale Entitätstypen:
Existieren um ihrer selbst willen. Die Entitäten fundamentaler Entitätstypen
repräsentieren eindeutige Objekte der realen Welt. Beispiele für solche Entitätstypen
sind „Geschäftspartner“ oder „Artikel“.
Entitäten assoziativer Entitätstypen:
Drücken einen fachlichen Zusammenhang zwischen fundamentalen Entitäten aus und
haben eigene Attribute. Sie haben eine Art „Zwitterfunktion“, da sie auch als
Beziehungstypen angesehen werden können. Ein Beispiel für einen solchen Entitätstyp
ist „Auftragsposition“, der auch als Beziehungstyp zwischen „Auftrag“ und „Artikel“
angesehen werden kann.
2.1.2 ENTITÄTSMENGEN (ENTITY SETS)
Ähnliche Entitäten können zu Entitätsmengen zusammengefasst werden. So könnten die
Subentitäten Kunde, Lieferant und Bank unter Superentität Geschäftspartner
zusammengefasst werden.
- 18 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 2: Super- und Subentitätstypen mit „is a“ Operator
[Quelle: Rautenstrauch/Schulze (2003) S. 237]
Für die Modellierung von Super- und Subentitätstypen wird der „is a“- Operator als
Dreieck eingeführt. Auf der Spitze des Dreiecks wird der Superentitätstyp und auch der
Unterseite werden die Subentitätstypen notiert. Die Erzeugung von Superentitätstypen
durch Zusammenfassen gemeinsamer Attributsmengen verschiedener Entitätstypen
wird Generalisierung und das „Herausziehen“ von Subentitätstypen mit disjunkten
eigenen Attributsmengen wird Spezialisierung genannt.
2.1.3 ATTRIBUTE UND SCHLÜSSEL
Entitätstypen werden durch Attribute, d.h. Eigenschaften bzw. Merkmale,
charakterisiert. Eine bestimmte Entität ist durch spezifische Werte für die Attribute
gekennzeichnet.
Ein Attributstyp Kunde besitzt beispielsweise die Attribute Name, Straße, Wohnort und
Kundennr. In der graphischen Darstellung werden Entitäten durch Ellipsen dargestellt.
Abbildung 3: Entitätsmenge mit Attributen
- 19 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Bestimmte Attribute werden benutzt, um Entitäten voneinander zu unterscheiden.
Hierfür eignen sich aber nur solche Attribute oder Attributkombinationen, die
Eindeutigkeit gewährleisten. Solche Attribute oder Attributkombinationen werden auch
als Schlüsselkandidaten bezeichnet, da sie sich für Primärschlüssel in den späteren
Tabellen nahezu anbieten. Primärschlüssel werden in ER-Diagrammen unterstrichen
dargestellt.
Jedes Attribut hat einen Wertebereich (Datentyp). So kann ein Attribut beispielsweise
einen Zeitpunkt (Geburtsdatum), eine Zahl (Mahnstufe), einen Text (Name) usw.
bezeichnen. Man kann einfache Attribute, die aus einer einzelnen Komponente mit einer
unabhängigen Existenz bestehen (wie Geschlecht oder Gehalt) und zusammengesetzte
Attribute, die aus mehreren Komponenten zusammengesetzt sind, die wiederum eine
eigene Existenz besitzen, unterteilen (z.B. Das Attribut Adresse besteht aus Strasse,
Postcode und Ort). [vgl. Connolly et al. (2002) S 186f]
2.1.4 BEZIEHUNGEN (RELATIONSHIPS)
Eine Beziehung (auch als Relation bezeichnet) ist eine Verknüpfung zwischen
verschiedenen Entitäten. So kann z.b. die Entität „Kunden“ mit der Entität „Konto“ in
Beziehung stehen, indem der Kunde ein Konto besitzen kann.
Anhaltspunkt dafür, was als Entitätstyp und was als Beziehungstyp bezeichnet werden
kann, ist die Verwendung von Substantiven bzw. von Verben. Entitätstypen werden in
der Regel mit Substantiven; Beziehungstypen in der Regel mit Verben bezeichnet. [vgl.
Heinrich (2001), S. 246]
Normalerweise verknüpft man jeweils zwei Entitäten über eine Relation. In diesem Fall
spricht man von einer zweiwertigen oder binären Relation.
Abbildung 4: Einfaches Symbol eines Beziehungstyps für einfache Darstellbarkeit
Abbildung 5: Formal richtiges Beziehungssymbol der ER-Modell Konvention
- 20 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Die Bedeutung, die einem Entitätstyp in einer Beziehung zukommt, nennt man auch
seine Rolle. Die Rolle des Entitätstypen „Kunde“ im obigen Beispiel ist
„Kontoinhaber“. Wenn ein Entitätstyp mehrere Beziehungen eingeht, kann er auch
mehrere Rollen einnehmen.
2.1.5 KARDINALITÄTEN VON BEZIEHUNGEN
Die semantische Aussagekraft eines Datenmodells bezüglich der Abbildung der
betrieblichen Realität kann durch die Angabe der Kardialität eines Beziehungstyps
gesteigert werden. Die Kardialität ist eine quantitative Spezifikation für die Menge der
auftretenden Beziehungen. Beziehungen kann man grundsätzlich in Kann-Beziehungen
und Muss-Beziehungen einteilen. Bei einer Kann-Beziehung müssen nicht alle Objekte
eines Objektsatzes durch die Beziehung angesprochen werden. Dadurch muss nicht
jeder Artikel im Lager gleichzeitig als Position in einer Bestellung auftauchen. Bei einer
Muss-Beziehung ist dies aber sehr wohl der Fall. So muss z.b. jeder Mitarbeiter einer
Unternehmung einer Abteilung zugeordnet werden. [vgl. Morcinek (2002) S. 218f]
Grad
1 zu 1
1 zu N
Ausprägung
"Kann"
"Muss"
Beziehung
Beziehung
[1,1]
[0,1]
[1,*]
[0,*]
Tabelle 1: Kombinationen von Grad und Ausprägung
Grundsätzlich lassen sich folgende Kardinalitäten unterscheiden:
2.1.5.1
1-1 BEZIEHUNGEN
Einer Entität wird genau eine Entität zugeordnet. Beispiel: Ein Mitarbeiter hat genau
einen Hauptwohnsitz. „Diese Beziehungen sind in der Realität eher selten anzutreffen,
da Entitäten zwischen denen eine solche Beziehung besteht, theoretisch in einer Entität
zusammengefasst werden können“ [vgl. Rautenbach/ Schulze (2003) S. 131] .
Abbildung 6: 1:1 Beziehung zwischen Kunde und Hauptwohnsitz
- 21 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
2.1.5.2
1-N BEZIEHUNGEN
Einer Entität werden mehrere oder eine Entität zugeordnet. Beispiel: In einer Abteilung
können mehrere Mitarbeiter arbeiten.
Abbildung 7: 1:n Beziehung zwischen Abteilung und Mitarbeiter
2.1.5.3
M-N BEZIEHUNGEN
Mehrere Entitäten werden mehreren anderen Entitäten zugeordnet. Beispiel: Ein
Mitarbeiter bearbeitet mehrere Projekte. Ein Projekt wird von mehreren Mitarbeitern
bearbeitet.
Abbildung 8: m:n Beziehung zwischen Mitarbeiter und Projekt
2.1.5.4
DIE REKURSIVE BEZIEHUNG
Eine rekursive Beziehung ist eine Beziehung von Entitäten des gleichen Typs.
Standardbeispiel ist die Beziehung „ist Vorgesetzter von“ eines Entitätstyps
„Mitarbeiter“. Zu beachten ist hier auch die alternative Darstellungsmöglichkeit von
Beziehungen durch eine Raute (im Unterschied zu der in Abbildung 6 verwendeten
einfachen Darstellung).
- 22 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 9: Rekursiver Beziehungstyp [Quelle: Rautenstrauch/Schulze (2003) S. 237]
2.2 LOGISCHES DATENMODELL
2.2.1 ALLGEMEINES
Ein logisches Modell beschreibt die Daten eines Informationssystems auf der Ebene des
DV-Konzepts. Unter den logischen Datenmodellen spielen vor allem vier Modelle eine
Rolle:
•
Hierarchisches Datenmodell
•
Netzwerkdatenmodell
•
Relationales Datenmodell
•
Objektorientiertes Datenmodell
•
Objektrationonales Datenmodell
Das in der Praxis wichtigste Datenmodell ist das „Relationale Modell“. Dieses
werde ich auch als Basis für meine Datenmodellierung der Applikation verwenden,
da mit Microsoft SQL als Datenbank für unsere Anwendung und das
Datawarehouse eine relationale Datenbank gewählt wurde.
- 23 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
2.2.2 DATENMODELLE
2.2.2.1
HIERARCHISCHES DATENMODELL
Das hierarchische Datenbankmodell basiert auf der mathematischen Baumstruktur.
Wenn wir die einzelnen Dateien einer hierarchischen Datenbank als Knoten bezeichnen,
so gelten folgende Vereinbarungen: Wie bei Verzeichnisstrukturen der meisten
Betriebssysteme gibt es eine Wurzel. Dieser Knoten hat keinen Vorgänger und leitet
alle anderen ab. Hat ein Knoten keinen Nachfolger wird er als Blatt bezeichnet.
Abbildung 10: Firmenhierarchie
- 24 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Vorteile:
•
Einfacher Aufbau
•
Sehr kurze Zugriffszeiten
•
Minimale Redundanz
Nachteile:
•
Strukturveränderungen kaum möglich
•
Komplexe Programmierung
2.2.2.2
NETZWERKDATENMODELL
Das Netzwerkmodell beruht wie das hierarchische Modell auf der Graphentheorie,
allerdings gibt es keine hierarchische Struktur und jeder Knoten kann mit jedem Knoten
verbunden sein. Analog zur Abbildung 10 könnte also ein Arbeiter auch Mitglied in
zwei Abteilungen sein.
Vorteile:
•
Kurze Zugriffszeiten
•
Geringe Redundanz
Nachteile:
•
Strukturveränderungen nicht einfach
•
Relativ komplexe Programmierung
2.2.2.3
RELATIONALES DATENMODELL
Das relationale Modell, das von Codd entwickelt wurde, basiert auf einer
mathematischen Grundlage, der Relationenalgebra. Eine relationale Datenbank besteht
ausschließlich aus Tabellen. Ein Zugriff erfolgt immer über diese Tabellen. Die
Zusammenhänge zwischen den Tabellen werden über Beziehungen hergestellt. Diese
Beziehungen werden über Primär- und Fremdschlüssel abgebildet.
Das relationale Datenmodell ist tupelorientiert, die Information wird durch Relationen
repräsentiert. Eine Relation R ( A1 , A2 ,..., An ) ist eine bekannte Menge von n-Tupeln,
wobei n-Tupel eine Anordung von n atomaren, das heißt einfachen (nicht weiter
zerlegbaren) Attributen (attributes) A1 , A2 ,..., An ist. [vgl. Schneider/Weber (2000) S. 471]
- 25 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Vorteile:
•
Leichte Änderbarkeit des Datenbankaufbaus
•
Mathematisch fundiert
•
Leicht programmierbar und verwaltbar
Nachteile:
•
Häufig viele Ein-/Ausgaben notwendig
•
Erfordert eine hohe Rechnerleistung
•
Erzeugt Redundanz
•
Komplizierte Objekte müssen erst in viele Tabellen zerlegt und beim Abfragen
wiederum mühevoll rekonstruiert werden.
Das relationale Modell ist das in der Praxis am häufigsten vorkommende Modell.
Relationale Datenbanken sind die wichtigsten Datenbankanwendungen in der heutigen
Zeit. Aus diesem Grund werde ich im Kapitel, das sich mit SQL beschäftigt im
speziellen auf die Grundlagen des relationalen Datenmodells und der Relationenalgebra
eingehen.
2.2.2.4
OBJEKTORIENTIERTES DATENMODELL
Eine objektorientierte Datenbank besteht ausschließlich auf Objekten. Ein Objekt ist
entweder ein realer Gegenstand oder ganz allgemein ein abstrakter Gegenstand. Da
viele Objekte auch in Tabellenform gespeichert werden können, werden
objektorientierte Datenbanken häufig als eine Erweiterung relationaler Datenbanken
angesehen. Dies trifft aber nur teilweise zu. Der Haupteinsatz von Objektorientierten
Datenbankmanagementsystemen liegt in der Bereitstellung von Datenbankeigenschaften
für objektorientierte Anwendungen, insbesondere für solche, die durch die traditionellen
Datenmodelle und –systeme nur unzureichend unterstützt wurden. Beispiele für solche
Anwendungsgebiete sind Entwurfsanwendungen (CAD, CASE), GeoInformationssysteme (GIS), wissenschaftliche Anwendungen und Gebäudetechnik
(Facility Management). Ein signifikantes Eindringen in die traditionellen
Anwendungsbereiche relationaler Systeme ist ihnen jedoch nicht gelungen. [vgl. Geppert
(2002) S. 30f]
- 26 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Vorteile:
•
Objektorientierter Aufbau
•
Universell einsetzbar
•
Noch relativ einfach programmierbar und verwaltbar
•
(teilweise) kompatibel zu relationalen Datenbanken
Nachteile:
•
relativ viele Ein-/Ausgaben notwendig
•
erfordert eine relativ hohe Rechenleistung
•
teilweise recht komplexer Aufbau
2.2.2.5
OBJEKTRELATIONALES DATENMODELL
Das objektrelationale Datenmodell steht als hybride Konstruktion zwischen dem
relationalen und dem Objektdatenmodell. Das relationale Datenmodell wird dabei um
folgende Elemente des Objektdatenmodells erweitert:
Strukturierte Objekte:
Aus den vorhandenen Datentypen können komplexere (nicht atomare) Strukturen
definiert werden.
Untertypen:
Aus existierenden Typen können durch Spezialisierung neue gebildet werden
(Untertypen). Diese erben alle Charakteristika des Obertyps.
Erweitertes und erweiterbares Typsystem:
Erweiterungen des relationalen Datenmodells um neue Typen (z.b. für
Multimediadateien). Das Typsystem kann durch selbst definierte Typen erweitert
werden.
Referenzen:
Zwischen den Datenelementen (d.h. Tupeln) können Beziehungen definiert werden, die
nicht über Fremdschlüsselbeziehungen abgedeckt werden.
[vgl. Schneider/Werner (2000) S. 475f]
2.2.3 ÜBERFÜHRUNG DES ER-MODELLS INS RELATIONALE MODELL
Auf der Erfahrung ergibt sich eine bestimmte Vorgehensweise beim Umsetzen des ERModells ins relationale Modell. Für die Umsetzung bestehen aber Freiheitsgrade und
- 27 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Gestaltungsmöglichkeiten bei der Wahl der Relationen und ihrer Attribute. Das heißt
die Umsetzung kann auch weit von diesen „Standardregeln“ der Umsetzung abweichen.
Häufig wird für jeden Entitätstyp zunächst eine eigene Tabelle angelegt. Beziehungen
werden dadurch abgebildet, dass in einer Tabelle ein Verweis auf einen Eintrag in einer
anderen Tabelle eingefügt wird. Enthält eine Tabelle in einem Attribut oder einer
Attributkombination einen Verweis auf eine andere Tabelle, so werden diese Attribute
auch Fremdschlüssel (foreign key oder Sekundärschlüssel) genannt, da sie einen
Verweis auf den Primärschlüssel einer anderen Relation darstellen.
Jeder Wert eines Fremdschlüssels sollte auch als Wert im Primärschlüssel einer anderen
Relation vorkommen. Diese Eigenschaft eines Relationenmodells bezeichnet man auch
als referenzielle Integrität.
- 28 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Die einzelnen Beziehungstypen werden üblicherweise im Relationenmodell wie folgt
behandelt:
2.2.3.1
DIE UMSETZUNG DER 1:1 BEZIEHUNG
Bei einer 1:1 Beziehung wird eine beliebige der beiden für die Entitätstypen erstellten
Tabellen um die Attributsspalte(n) des Primärschlüssels der anderen Tabelle ergänzt.
Dabei muss jedoch überdacht werden, ob es sich bei dieser 1:1 Beziehung tatsächlich
um zwei Entitäten handelt oder ob diese Entitäten eigentlich dasselbe Objekt
verkörpern.[vgl. Connolly et al. (2002) S. 279]
Abbildung 11: Beispielhafte Umsetzung einer 1:1 Beziehung in das Realtionenmodell in der
vereinfachten Darstellung der Beziehung [Quelle: Baldi (1999), S. 84 ]
- 29 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
2.2.3.2
DIE UMSETZUNG DER 1:N BEZIEHUNG
Bei einer 1:n Beziehung wird die Tabelle der „n-Seite“ um die Attributsspalten des
Primärschlüssels der anderen Tabelle erweitert.
Abbildung 12: Beispielhafte Umsetzung einer 1:n Beziehung in das Relationenmodell in der
vereinfachten Darstellung der Beziehung [Quelle: Baldi (1999), S. 84]
2.2.3.3
DIE UMSETZUNG DER M:N BEZIEHUNG
Bei einer m:n Beziehung wird eine zusätzliche Tabelle eingeführt, die als Attribute die
Primärschlüsselattribute beider Entitätstypen erhält. Der Primärschlüssel dieser neuen
Relation ergibt sich aus der Kombination der beiden Ursprungsprimärschlüssel.
- 30 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 13: Beispielhafte Umsetzung einer m:n Beziehung in das Relationenmodell in der
vereinfachten Darstellung der Beziehung [Quelle: Baldi (1999), S. 84 ]
2.2.3.4
DIE UMSETZUNG EINER REKURSIVEN BEZIEHUNG
Eine rekursive Beziehung wird analog zu einer 1:1 oder 1:n Beziehung umgesetzt. Die
einzige Unterscheidung zwischen den oben angeführten Varianten ist, dass bei der
rekursiven Beziehung die Zeiger auf die gleiche Tabelle zeigen. Deshalb funktioniert
die Generierung dieser Tabelle analog.
2.3 PHYSISCHES DATENMODELL
Das physische Datenmodell beschreibt die Daten des Informationssystems auf der
Ebene der technischen Implementierung. Das physische Datenmodell bezieht sich auf
eine konkrete Datenbank und die Tables, welche real physisch in der Datenbank durch
„CREATE TABLE“ Anweisungen erzeugt werden. Diese SQL-Anweisungen werden
beispielhaft im Kapitel 7.8.3.4 erläutert.
- 31 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
3 SQL UND DATENBANKEN
3.1 DATENBANKEN
3.1.1 ENTWICKLUNGSGESCHICHTE DER DATENBANKSYSTEME
Im Laufe der Jahrzehnte wurde eine ganze Reihe von Konzepten entwickelt, die
Datenbestände möglichst sicher, effizient und eventuell benutzerfreundlich verwalten
können. Die Kernidee war Daten und Anwendungsprogramme zu trennen.
Im Jahre 1959 entwickelten Techniker der Firma IBM das Ramac-System, das man
vielleicht als frühen Vorläufer nachfolgender Datenbanksysteme bezeichnen darf. Mit
diesem System wird erstmalig der nichtsequentielle Datenzugriff verwirklicht. Ein
echter theoretischer Ansatz zur Datenbankverwaltung wird aber erst Anfang der
Sechziger Jahre entwickelt. Der Mathematiker Bachmann entwirft und veröffentlicht in
den Jahren 1961 bis 1964 Datenstrukturdiagramme; er formuliert außerdem
Beziehungen zwischen den Daten, der Begriff der Beziehungstypen (sets) wird bereits
hier geprägt.
Dies ist die Grundlage für das von der Codasyl-Gruppe (Vereinigung der wichtigsten
amerikanischen Computerhersteller und Computeranwender) im Jahre 1971
verabschiedete Netzwerk Datenmodell. 1970 stellt E. Codd das relationale
Datenbankmodell vor. Im Jahre 1976 veröffentlichte Peter S. Chen zum Thema
Datenbankentwurf das Entity-Realtionsship Prinzip. Der entscheidende Schritt für die
relationale Datenbankwelt war im Jahre 1973 die Entwicklung des Systems R von IBM.
Dieses Datenbanksystem beinhaltete eine Anfragesprache namens SEQUEL, die im
Laufe der Projektentwicklung in SQL umbenannt wurde, mit welcher wir uns auch in
dieser Arbeit im Detail befassen wollen.
3.1.2 BEGRIFFSDEFINITIONEN
Die Begriffe Datenbank, Dateisystem, Datei usw. werden heute oft sehr sorglos und
ohne begriffliche Abgrenzung verwendet. Um diesem Abhilfe zu schaffen will ich diese
Begriffe hiermit im Vorfeld entsprechend definieren.
Datei
Eine Datei ist ein Datenbestand, der unter einem Dateinamen im Allgemeinen auf einem
externen Datenträger gespeichert ist. Dieser Datenbestand kann auch als Strom von Bits
interpretiert werden. Eine Datei hat immer einen Namen, um sie von anderen Dateien
unterscheiden zu können. [vgl. Rautenstrauch et al. (2003) S. 99]
- 32 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Daten
Daten sind Informationen, die in digitaler Form auf Softwaresystem abgespeichert
wurden. Daten können unformatiert (Text) oder formatiert sein.
Datenbank Management System (DBMS)
“Das DBMS (deutsch: Datenbankverwaltungssystem) ist eine spezielle Software, mit
der größere, gemeinsame Datenbestände (Datenbank) aufgebaut, manipuliert und
kontrolliert werden können“ [vgl. Fischer et al. (2000), S. 110]. Somit ist das DBMS die
Gesamtheit aller Programme zur Erzeugung, Verwaltung und Manipulation der Daten
[vgl. Schneider/Werner (2000) S. 469].
Datenbank
Eine Datenbank ist eine Sammlung von Daten, die untereinander in einer logischen
Beziehung stehen und von einem eigenen Datenbankverwaltungssystem (DBMS)
verwaltet werden. Kurz formuliert ein Datenbanksystem besteht aus Daten und einem
Datenbankmanagementsystem. [vgl. Schicker (1999), S. 46]
3.1.3 ANFORDERUNGEN EINES DATENBANKSYSTEMS
Anforderungen an ein Datenbanksystem sind:
Sammlung logisch verbundener Daten:
Da Daten auf mehrere Dateien verteilt sind, muss das Datenbanksystem diese Dateien
zusammenfügen, um die Information zu gewinnen.
Speicherung der Daten mit möglichst wenig oder keiner Redundanz:
Redundanz ist das mehrfache Speichern ein und der selben Information. Dies kann bei
Änderungen zu Differenzen führen und sollte vermieden werden. Deswegen sollte das
Datenbankverwaltungssystem die nicht vermeidbaren redundanten Daten automatisch
anpassen.
Abfragemöglichkeit und Änderbarkeit der Daten
Diese selbstverständliche Forderung schließt ein, dass das Abfragen und Ändern der
Daten entsprechend schnell ausgeführt wird.
Logische Unabhängigkeit der Daten von ihrer physischen Struktur:
Es genügt nicht, dass die Datenbank für die optimale Speicherung der Daten sorgt, der
Benutzer will darüber hinaus nicht einmal wissen, wie die Daten physisch abgespeichert
sind.
Zugriffsschutz:
Betriebssysteme kennen nur den Schutz von Dateien, nicht den Schutz von einzelnen
Daten innerhalb der Datei. Dieser interne Schutz ist aber bei sensiblen Daten, wie den
Personaldaten erforderlich. Zusätzlich ergibt sich die Entwicklung verschiedener
- 33 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Sichten (Views) der Benutzer abhängig von den Rechten, welche diese besitzen [vgl.
Schneider/Werner (2000) S. 470].
Integrität:
Integrität kommt von INTEGER und bedeutet hier, dass alle gespeicherten Daten
korrekt sein müssen.
Mehrfachzugriff:
Auf die Forderung nach Datenzugriffen von mehreren Rechnern oder Terminals aus
kann in der Regel heute nicht mehr verzichtet werden.
Zuverlässigkeit:
Das bedeutet Sicherheit vor unerlaubten Zugriffen.
Ausfallssicherheit:
Bedeutet Sicherheit der Daten in allen nur erdenklichen Fällen, wie Rechnerausfall
oder Zerstörung durch Feuer.
Kontrolle:
Die Datenbank muss ständig Angaben über ihren momentanen Zustand machen können.
Diese Angaben sind z.B. Anzahl der Benutzer, Auslastung der Festplatten oder
Auslastung des DBMS.
Die Anforderungen an ein Datenbanksystem können zum Teil auch als die Vorteile
eines Datenbanksystems interpretiert werden. Tatsache ist, das der Einsatz von
Datenbanksystemen einen enormen Leistungssprung in der Softwareentwicklung
gebracht hat.
3.2 SQL ALS STANDARDISIERTE DATENBANKSPRACHE
3.2.1 GESCHICHTLICHES
Mit SQL steht eine Sprache zur Verfügung, mit der alle Funktionen auf relationalen
Datenbanken ausgeführt werden können. Basis von SQL ist die Relationenalgebra, die
eine mathematisch vollständige und konsistente Beschreibung sämtlicher auf
relationalen Datenbanken anwendbaren Operationen bietet.
Seit 1974 IBM mit SEQUEL die erste relationale Datenbanksprache auf den Markt
brachte, hat sich die in den Folgejahren daraus entwickelte Sprache SQL weiter
verbreitet, um sich schließlich ab 1982 als ANSI-Standard allgemein durchzusetzen.
Seit dem ist eine ständige Weiterentwicklung im Fluss. 1987 wurde der ANSI-Standard
SQL-1 geschaffen und 1989 der verbesserte ANSI-Standard SQL-2. Die ISO schloss
sich dieser Standardisierung an, und auch in der deutschen Norm DN66315 ist SQL-2
- 34 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
festgelegt. In den Weiterentwicklungen SQL-3 und SQL-4 wurden schließlich
objektorientierte Konzepte integriert.
SQL-1 und SQL-2 sind nicht zu den prozeduralen Sprachen der dritten Generation zu
rechnen, da sie keine allgemeinen Methoden zur Formulierung von Algorithmen
enthalten. So gibt es keine Schleifenkonstrukte und ähnliches. Als Ausgleich dafür
besteht aber die Möglichkeit mit Embedded SQL , SQL-Statements in prozedurale oder
objektorientierte Sprachen einzubetten. Erst durch SQL-3 wurde SQL vollständig und
es kann auch mit SQL jeder Algorithmus ausgedrückt werden.
SQL ist eine Sprache der vierten Generation (4GL). Das heißt in SQL wird nicht
beschrieben, wie ein Datenbankzugriff zu erfolgen hat, es wird vielmehr beschrieben,
was der Anwender beabsichtigt. Vor der Ausführung von SQL-Anweisungen muss
daher eine algorithmische Umsetzung in prozedurale Anweisungen erfolgen, da nur
solche durch einen Computer ausführbar sind. Das hat den großen Vorteil, dass SQL auf
allen Arten von Datenbanken einsetzbar ist.
Seit Jahren arbeitet nun ein Herstellerkonsortium namens SQL Access Group an der
Definition von Einrichtungen zur Verbesserung der Interoperabilität zwischen
unterschiedlichen SQL-Implementierungen. Sie versuchen somit den Standard laufend
zu aktualisieren und zu verbessern. Die aktuelle Sprachversion von SQL heißt SQL-99.
Das entsprechende Standarddokument ist Ende des Jahres 1999 in Kraft getreten – als
offizielles Publikationsdatum wird der 15. November 1999 angegeben – und hat damit
das bisher gültige Standarddokument aus dem Jahre 1992 abgelöst.
Die SQL-Standardisierungskommission vermeidet es, von Relationen, Tupeln und
Attributen zu sprechen. Statt dessen werden Ausdrücke wie Tabelle, Zeile und Spalte
verwendet. Um bei einer sauberen Begriffsverwendung zu bleiben werde ich versuchen
die Begriffe anschließend kurz zu definieren und aufzulisten.
Relationaler Ausdruck
Relation (Menge)
Tupel
Attribut
SQL-Ausdruck
Tabelle
Zeile
Spalte
Tabelle 2: Gegenüberstellung von relationalen und SQL-Ausdrücken [Quelle: Pernul/Unland
(2001) S. 263]
SQL wurde als mengenorientierte Sprache konzipiert und hat damit den Vorteil enorm
benutzerfreundlich zu sein. Der Benutzer kann in einer Sprache, die an die Englische
Sprache angelehnt ist, seine Anforderungen an die Datenbank formulieren und erhält
eine entsprechende Ergebnismenge geliefert.
- 35 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
SQL ist sowohl eine DDL (Data Definition Language), eine DML (Data Manipulation
Language) als auch eine DCL (Data Control Language). Diese Unterscheidung ist sehr
wichtig und essentiell und sollte jedem Benutzer von SQL ständig im Bewusstsein
bleiben. Für zusätzliche Publikationen über die Historie von SQL verweise ich auf Goos
(2000), S. 108ff, Härder/Rahm (2001) S. 531, Hartmut (2000), S. 691f und Redaktion
Toolbox (2002) S. 597ff.
3.2.2 DAS RELATIONALE MODELL
Das Relationale Modell, welches als das bedeutendste Datenmodell der Jetztzeit gilt,
geht auf E.F. Codd zurück, der mit Recht als Schöpfer des Relationenmodells
bezeichnet werden kann. In seiner zukunftsweisenden Abhandlung „A relational model
of data banks“ (1970) stellte er erstmals das Relationenmodell vor. Auf Grund der
Bedeutung und realen Anwendung im Zuge meiner Arbeit, will ich detaillierter und
ausführlicher auf die Begriffe und Grundlagen dieses Modells eingehen.
3.2.2.1
RELATIONALE DATENSTRUKTUR
3.2.2.1.1
DOMÄNEN:
Im relationalen Modell werden die Daten als Relationen repräsentiert. Eine Relation ist
auf Domänen definiert.
Eine Domäne
•
stellt einen Wertevorrat bereit. Die Werte werden dabei als atomar (skalar,
elementar) vorausgesetzt.
•
hat einen Namen.
Diese Eigenschaften gelten im wesentlichen auch für Datentypen, wie sie in höheren
Programmiersprachen unterstützt werden. Tatsächlich kann man sich eine Domäne als
eine Art Datentyp vorstellen. Das Domänenkonzept unterscheidet sich aber
dahingehend, dass der Domänenname von Benutzer selbst definiert wird.
3.2.2.1.2
RELATIONEN:
Eine Relation über den Domänen D1, D2, ...., Dn besteht aus einem Relationenkopf
(heading) und einem Relationenrumpf (body).
Der Relationenkopf besteht aus einer festen, im Zeitablauf nicht änderbaren Menge von
Attributen A1, A2,..., An, so dass jedes Attribut Ai genau einer der zugrundeliegenden
- 36 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Domänen entspricht. Die (feste) Anzahl n der Attribute wird als Grad (degree) der
Relation bezeichnet.
Der Relationenrumpf besteht aus einer variablen, im Zeitablauf veränderlichen Menge
von n-Tupeln, wobei jedes n-Tupel wiederum eine Menge von (Attribut:Wert)-Paaren
(Ai : vi ), i=1,...,n ist. Für jedes Paar (Ai : vi ) ist vi ∈ Di. Die Anzahl der n-Tupel wird
Kardinalität der Relation genannt.
•
Ein Attribut Ak hat einen innerhalb der Relation eindeutigen Namen,
•
der einen Bezug zur zugrundeliegenden Domäne Dk herstellt,
•
einen Bezug zum dazugehörigen Wert vk herstellt.
[vgl. Panny/Taudes (2000) S. 23f]
Abbildung 14: Relationale Datenstruktur [in Anlehnung: Panny/Taudes (2000) S. 23]
3.2.2.1.3
EIGENSCHAFTEN VON RELATIONEN
Für Relationen nach der obigen Definition ergeben sich folgende Eigenschaften:
•
Es kann niemals mehrfach auftretende identische Tupel in einer Relation
geben.
•
Die Tupel einer Relation sind nicht geordnet.
•
Auch die Attribute einer Relation sind nicht geordnet.
•
Alle Attributswerte sind atomar.
- 37 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
3.2.2.2
RELATIONALE INTEGRITÄT
3.2.2.2.1
SCHLÜSSELKANDIDAT (CANDIDATE KEY)
Sei R eine Relation mit den Attributen A1, A2,..., An.. Die Menge K= {Ai1, Ai2,..., Aim},
m>=1, heißt Schlüsselkandidat von R genau dann, wenn unabhängig vom Zeitpunkt
(also über die gesamte Lebensdauer der Relation R) gilt:
•
Eindeutigkeit: Zu keinem Zeitpunkt gibt es zwei Tupel mit demselben Wert für
K.
•
Minimalität: Keines der Attribute Ai1, Ai2,..., Aim kann weggelassen werden, ohne
die Eindeutigkeit von K zu verliehren.
3.2.2.2.2
PRIMÄRSCHLÜSSEL (PRIMARY KEY)
Für jede gegebene Relation R muss einer der Schlüsselkandidaten als Primärschlüssel
festgelegt werden. Die übrigen Schlüsselkandidaten heißen Alternativschlüssel
(alternative keys).
3.2.2.2.3
FREMDSCHLÜSSEL (FOREIGN KEY)
Ein Fremdschlüssel ist ein Menge von Attributen einer Relation R2. Es gibt nun in der
Datenbank eine Relation R1, so dass jeder in R2 auftretende Fremdschlüsselwert auch als
Primärschlüsselwert in R1 vorkommt. Die Relationen R1 und R2 sind nicht
notwendigerweise verschieden.
3.2.2.2.4
ENTITÄTSINTEGRITÄT
Für jede definierte Relation muss ein Primärschlüssel festgelegt sein. Kein zum
Primärschlüssel einer Relation gehörendes Attribut, darf Nullwerte annehmen.
3.2.2.2.5
REFERENZIELLE INTEGRITÄT (REFERENTIAL INTEGRITY)
Sei R2 eine Relation, die mit einem Fremdschlüssel F auf die Relation R1 mit dem
Primärschlüssel P zeigt. Für jeden in R2 auftretenden Wert von F muss gelten:
•
Er enthält entweder in keiner seiner Komponenten einen Nullwert oder alle
seine Komponenten sind mit Nullwerten markiert.
•
Wenn er vollständig definiert ist, muss in R1 ein Tupel existieren, welches
diesen Wert als P-Wert aufweist.
- 38 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Es ist durchaus erlaubt und möglich, dass R1 und R2 identisch sind. In einem solchen
Fall spricht man von einem Selbstbezug.
3.2.2.3
RELATIONALE DATENMANIPULATION
Man unterscheidet grundsätzlich zwei Arten der Datenmanipulation: die Mutation und
die Abfrage. Während bei der Abfrage nichts am Zustand der Daten oder Tupel
verändert wird, ist die Mutation das Hinzufügen, Ändern und Löschen von Daten.
Die Operationen der Relationenalgebra werden nach Panny/Taudes [vgl. Panny/Taudes
(2000) S. 31f] wie folgt eingeteilt:
•
Selektion:
Extrahiert bestimmte Tupel aus einer Relation und bildet somit eine horizontale
Teilrelation.
•
Projektion:
Extrahiert bestimmte Attribute aus einer Relation und bildet somit eine vertikale
Teilrelation.
•
Produkt:
Erzeugt aus zwei Relationen eine neue Relation, die aus allen möglichen Tupeln
besteht, welche man durch Verketten eines Tupels der ersten Relation mit einem
Tupel der zweiten Relation bilden kann.
•
Vereinigung:
Erzeugt aus zwei Relationen eine neue Relation, welche die Tupel beider
Relationen enthält.
•
Differenz:
Erzeugt aus zwei Relationen eine neue Relation, welche die gemeinsamen Tupel
beider Relationen enthält.
•
Verbund:
Erzeugt aus zwei Relationen eine neue Relation, die aus allen möglichen Tupeln
besteht, welche man durch Verketten eines Tupels der ersten Relation mit einem
Tupel der zweiten Relation bilden kann, so dass jedes dieser Paare eine
vorgegebene Bedingung erfüllt.
•
Division:
Erzeugt aus zwei Relationen eine neue Relation. Nehmen wir fürs erste
vereinfachend an, die Dividendenrelation habe Grad 2 (sei binär) und die
Divisorrelation habe Grad 1 (sei unär). Dann besteht die Quotientenrelation aus
- 39 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
all jenen Werten des einen Attributs der binären Relation, für die alle Werte der
unären Relation im zweiten Attribut vorkommen.
3.2.2.4
NORMALFORMEN
Normalformen stellen ein Messverfahren für die Qualität und Güte eines
Relationsschemas dar. Sie helfen, Anomalien zu entdecken und damit Redundanzen zu
vermeiden [vgl. Pernul/Unland (2001) S. 140ff]. Die Unterscheidung der Normalformen
basieren auf Codd (1970). In der Folge wird auf die wichtigsten Typen von
Normalformen eingegangen..
3.2.2.4.1
ERSTE NORMALFORM (1NF)
Die Wertebereiche aller Attribute des Relationsschemas müssen atomar sein. Die erste
Normalform verlangt, dass alle Attibutwerte aus einem unstrukturierten Wertebereich
stammen. Mengen, Aufzähltypen, Wiederholungsgruppen oder komplex strukturierte
Wertebereiche sind nicht zugelassen.
3.2.2.4.2
ZWEITE NORMALFORM (2NF)
Die zweite Normalform bedeutet, dass es keine Teilmenge eines Schlüsselkandidaten
geben darf, die ein nicht primes Attribut funktional bestimmt. Um die zweite
Normalform überprüfen zu können, muss man zuvor alle Schlüsselkandidaten ermitteln,
denn nur Attribute, die in keinem Schlüsselkandidaten enthalten sind, können die zweite
Normalform verletzen.
3.2.2.4.3
DRITTE NORMALFORM (3NF)
Die dritte Normalform setzt die zweite Normalform voraus und fordert zusätzlich, dass
zwischen einem nicht-primen Attribut und einem Schlüsselkandidaten keine transitive
funktionale Abhängigkeit existieren darf.
Funktionale Abhängigkeiten sind im Relationenmodell die wichtigste Klasse von
Einschränkungen. Sie werden verwendet, um die Anzahl der mathematisch möglichen
Tupel (kartesisches Produkt der Attributswertebereiche) auf die Menge der semantisch
sinnvollen Tupel einzuschränken. Die funktionale Abhängigkeit X → Y (X bestimmt Y
funktional) gilt im Schema R, falls alle beliebigen Tupel t1 , t 2 aus der Relation r(R), die
in ihren X-Werten übereinstimmen, auch in ihren Y-Attributen identische Werte
aufweisen.
- 40 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
3.2.2.4.4
BOYCE-CODD-NORMALFORM (BCNF)
Die Boyce-Codd-Normalform setzt die dritte Normalform voraus. Sie ist die einzige
Normalform, die durch gültige funktionale Abhängigkeiten und nicht durch nicht-prime
Attribute verletzt werden kann. In Relationsschemata in der Boyce-Codd-Normalform
gibt es keine nennenswerten Anomalien mehr.
3.2.2.4.5
VOR- UND NACHTEILE DER NORMALISIERUNG
Nachteile der Normalisierung:
•
Unübersichtlichere und schwieriger zu handhabende Datenbanken, da durch die
Normalisierung mehr Tabellen entstehen.
•
Höhere Antwortzeiten durch die Notwendigkeit, Views einzuführen sowie Joins
bei Datenbankabfragen zu verwenden.
Vorteile der Normalisierung:
•
Verminderung von Redundanz durch Auslagerung von redundanter Information
in separate Tabellen.
•
Weniger Anomalien.
•
Mehr Konsistenz.
•
Speicherplatzersparnis.
[vgl. Kleinschmidt/Rank (2002) S. 78]
3.2.2.5
SICHTEN (VIEWS)
Ein View kann auch als virtuelle Relation bezeichnet werden, welche nicht selbständig
besteht, sondern dynamisch von einer oder mehreren Grundrelationen abgeleitet wird.
Eine Sicht kann durch Operationen wie die Auswahl, Projektion und Verknüpfung der
relationalen Algebra oder anderen Berechnungen aus den Werten der Grundrelationen
erzeugt werden.
3.2.2.5.1
TERMINOLOGIE
„Eine Sicht ist das dynamische Ergebnis einer oder mehrerer relationaler Operationen,
die an einer Grundrelation ausgeführt wurden, um eine andere Relation zu erzeugen.
Eine Sicht ist eine virtuelle Relation, die nicht tatsächlich in der Datenbank vorhanden
ist, sondern auf die Anfrage des einzelnen Benutzers zu Zeit der Anfrage erzeugt wird.“
[vgl. Connolly et al. (2002) S. 138]
- 41 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
3.2.2.5.2
ZWECK VON SICHTEN
Der Zweck, bzw. die Vorteile von Sichten sind:
•
Teile der Datenbank bleiben vor bestimmten Benutzern verborgen. Dies liefert
einen leistungsfähigen und flexiblen Sicherheitsmechanismus.
•
Es erlaubt den Benutzern, auf eine ihren Bedürfnissen angepasste Weise auf die
Daten zuzugreifen, so dass dieselben Daten für verschiedene Benutzer zur
selben Zeit auf unterschiedliche Weise sichtbar sind.
•
Er kann komplexe Operationen an Grundrelationen vereinfachen. Wenn eine
Sicht zum Beispiel als Verknüpfung zweier Relationen definiert ist, kann der
Benutzer nun die einfacheren Operationen der Auswahl und Projektion an der
Sicht durchführen. Das Datenbanksystem übersetzt sie in die entsprechenden
Operationen an der Verknüpfung.
[vgl. Connolly et al. (2002) S. 138f]
3.2.2.5.3
AKTUALISIERUNG VON SICHTEN
Alle Aktualisierungen einer Grundrelation sollten sich unmittelbar in allen Sichten
widerspiegeln, die sich auf diese Grundrelation beziehen. Ebenso sollte die zugrunde
liegende Grundrelation die Änderung anzeigen, wenn eine Sicht aktualisiert wird. Es
gibt jedoch Einschränkungen in Bezug auf die Art der Änderungen, die mit Hilfe von
Sichten durchgeführt werden können.
Aktualisierungen mit Hilfe einer Sicht sind zulässig, wenn eine einfache Abfrage
bezogen auf eine einzelne Grundrelation benutzt wird, die entweder den Primärschlüssel
oder einen Schlüsselkandidaten der Grundrelation enthält.
Aktualisierungen mit Hilfe von Sichten sind nicht zulässig, wenn mehrere
Grundrelationen betroffen sind.
Aktualisierungen mit Hilfe von Sichten sind nicht zulässig bei Aggregations- oder
Gruppierungs-Operationen.
3.2.3 SQL NACH DEM STANDARD SQL 99
SQL als Datenbanksprache stellt die sprachliche Schnittstelle zum Anwender dar.
Damit stellt sie Beschreibungsmittel für die strukturellen und manipulativen Aspekte
der Daten bereit. Entsprechend werden üblicherweise die Teilsprachen
Datendefinitionssprache (DDL), Datenmanipulationssprache (DML) und
Datenkontrollsprache (DCL) der Datenbanksprache SQL unterschieden und unten
- 42 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
erläutert. Als weiterführende Literatur sei dabei Achilles (2000) S.119ff, Houlette
(2001) S. 59ff, Marsch/Fritze (1999) S. 57ff und Panny/Taudes (2000) S. 71ff genannt.
3.2.3.1
SQL ALS DDL
Ursprünglich gingen die ersten Versionen von SQL von der Vorstellung aus, dass die
Struktur einer Datenbank zeitlich festgeschrieben und durch die Struktur der Tabellen
und Zugriffsrechte festgelegt ist. Deshalb war ursprünglich nur vorgesehen
Datenbankobjekte anzulegen, nicht aber sie zu ändern oder zu löschen. Dies wurde erst
in späterer Folge in den Standard integriert.
Zum Erzeugen, Ändern und Löschen von DBMS-Objekten
(Datenbankmanagementsystem-Objekten) sieht der Standard drei Kategorien von
Anweisungen vor, die CREATE-, die ALTER- und die DROP-Anweisungen. Um
Zugriffsrechte an den erzeugten DBMS-Objekten zu vergeben bzw. zu entziehen, stehen
die GRANT- bzw. REVOKE-Anweisung zur Verfügung
Im Anschluss möchte ich Anhand der TABLE Anweisungen für jede einzelne Kategorie
exemplarisch die Struktur der SQL-Anweisungen demonstrieren, da eine intensivere
Betrachtung jedes einzelnen DBMS-Objektes (also auch Indizes, Views, …) separat den
Rahmen dieser Arbeit sprengen würde und diese analog betrachtet werden können.
3.2.3.1.1
ERZEUGEN VON DBMS-OBJEKTEN (CREATE)
Syntax:
CREATE TABLE table_name
( {spalten_name {domain_name | datentyp}
[spalten_constraint]
[DEFAULT voreinstellung]
[COLLATE anordnung]
| table_contraint
}, … );
3.2.3.1.2
ÄNDERN VON DBMS-OBJEKTEN (ALTER)
Syntax:
ALTER TABLE tabellen_name
{ ADD [COLUMN] spaltendefinition }
|
{ ALTER [COLUMN] spalten_name
{{ SET DEFAULT default } | { DROP DEFAULT }}
}
|
{ DROP [COLUMN] spalten_name {RESTRICT |
CASCADE}}
|
{ ADD table_constraint }
- 43 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
|
{ DROP CONSTRAINT constraint_name {RESTRICT |
CASCADE}}
Löschen von DBMS-Objekten (DROP)
Syntax:
DROP TABLE table_name { CASCADE | RESTRICT }
3.2.3.1.3
VERGABE VON RECHTEN (GRANT)
Syntax:
GRANT
{ ALL PRIVILEGES
| SELECT
| DELETE
| { INSERT [(spalte [, ...])}
| { UPDATE [(spalte [, ...])}
| { REFERENCES [(spalte [, ...])}
} [, ...]
ON [ TABLE ] table_name
TO { benutzer1 [, benutzer2, …] } | PUBLIC
[ WITH GRANT OPTION]
3.2.3.1.4
ENTZIEHEN VON RECHTEN (REVOKE)
Syntax:
REVOKE [ GRANT OPTION FOR]
Recht [, …] ON objekt
FROM { benutzer1 [, benutzer2, …] } | PUBLIC
{ CASCADE | RESTRICT}
3.2.3.2
SQL ALS DML
SQL als Datenmanipulationssprache unterstützt sowohl Abfragen (SELECT), als auch
Mutationen (INSERT, UPDATE, DELETE), welche die zugrunde liegenden Tabellen
verändern.
3.2.3.2.1
DIE SELECT ABFRAGE
Die Abfrage ist das mächtigste und vielseitigste Instrument das SQL zu bieten hat. Man
hat mit einer SQL Abfrage unglaubliche Möglichkeiten, die jedoch in den wenigsten
Fällen benutzt werden. Zumeist beschränken sich die Anwender auf einfachste
Abfragen.
Syntax:
SELECT [ ALL | DISTINCT ] selektionsliste
FROM tabellenreferenzen
- 44 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
[ WHERE suchbedingung ]
[ GROUP BY spaltenliste ]
[ HAVING gruppensuchbedingung ]
3.2.3.2.2
DIE INSERT ANWEISUNG
Syntax:
INSERT INTO tabelle
[ spalte i [, spalte j, ...])]
{ select_anweisung
| tab_konstruktor
| { DEFAULT VALUES
}
3.2.3.2.3
DIE UPDATE ANWEISUNG
Syntax:
UPDATE tabelle
SET spalte i = { ausdruck i | NULL | DEFAULT }
[, spalte j = { ausdruck j | NULL | DEFAULT }
...]
[ WHERE suchbedingung ]
3.2.3.2.4
DIE DELETE ANWEISUNG
Syntax:
DELETE FROM tabelle
[ WHERE suchbedingung]
3.2.3.3
SQL ALS DCL
SQL ist auch eine Datenkontrollsprache (DCL), die dazu dient die
Transaktionseinheiten festzulegen und Sperren auf die benutzten Datenbankobjekte
anzufordern.
Im vollen Sprachumfang von SQL-99 sind eigene Verbindungsanweisungen
(connection statements) vorgesehen mit Hilfe derer der Benutzer den Auf- bzw. Abbau
und die Verwaltung von SQL-Verbindungen explizit steuern kann. Insbesondere sind
nun im Prinzip auch mehrere gleichzeitig bestehende Verbindungen zu mehreren SQLServern und sogar serverübergreifende Transaktionen möglich. In Core SQL, das den
Sprachkern von SQL-99 darstellt, kann aber für einen SQL-Agenten immer nur eine
einzige Verbindung bestehen.
- 45 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Zu jeder SQL-Verbindung gehört auch eine SQL-Sitzung (SQL Session). Sie wird mit
dem Aufbau der Verbindung gestartet und mit dem Abbruch der SQL-Verbindung
beendet. Dabei sind folgende zum Kontext einer Sitzung gehörende Bestandteile von
Relevanz:
•
Die Benutzerkennung der SQL-Sitzung
•
Der Default-Katalogname
•
Der Default-Schemaname
•
Der SQL-Pfad
Diese zum Kontext der Sitzung gehörenden Charakteristika können nicht verändert
werden und haben einen Readonly Status. Die entsprechenden, zu Beginn der Sitzung
gesetzten Werte bleiben notwendigerweise bis zum Ende der Sitzung in Kraft.
Den Kern der Datenkontrolle bildet jedoch die Kontrolle über die Transaktionen. Eine
Transaktion umfasst eine Folge von nacheinander auszuführenden SQL-Anweisungen.
In Core SQL wird eine Transaktion durch die erste Anweisung gestartet, die den
Rahmen der Transaktion voraussetzt. Es gibt zwei Anweisungen um eine Transaktion
abzuschließen: COMMIT und ROLLBACK. Wird eine Transaktion durch COMMIT
beendet, werden alle Mutationen dauerhaft gespeichert. Wird eine Transaktion durch
ROLLBACK abgeschlossen, wird die Datenbank in den konsistenten Zustand vor der
Transaktion zurückgesetzt. Keine der im Rahmen der Transaktion durchgeführten
Anweisungen hat einen Effekt.
4 ERP-SYSTEME
ERP-Systeme (Enterprise Resource Planning) sind betriebliche Planungs- und
Steuerungssysteme. Wichtige Bestandteile dieser industriellen, meist sehr
umfangreichen, Softwaresysteme sind die Produktionsplanung und –steuerung, die
bedarfs- und verbrauchsgesteuerte Materialdisposition, die Fakturierung, die
Kundenbetreuung, die Buchhaltung und Projektplanung. Als führende Hersteller sind
SAP, PeopleSoft, Baan, Oracle und Edwards zu nennen. [vgl. Schneider/Werner S. 726]
Für unser Projekt sind die ERP-Systeme als Quelle für unsere Daten für das Data
Warehouse anzusehen. Diese ERP-Systeme bestehen aber wiederum aus
unterschiedlichen Datenbanken, wodurch eine einheitliche Datenschnittstelle über die
Einführung von Übertragungsregeln der Datentransformationsprozesse festgelegt
werden müssen [vgl. Seemann et al. (2001) S. 27].
- 46 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
5 DAS DATA WAREHOUSE
5.1 DAS KONZEPT DES DATA WAREHOUSE
Unternehmen sind heutzutage prozess- oder transaktionsorientiert. Durch viele
Standardsoftwareanbieter werden Geschäftsprozesse durch das Erfassen von
Transaktionen abgebildet und erfasst. In Management- und Informationssystemen, die
der Entscheidungsunterstützung und Entscheidungsfindung dienen, benötigt man jedoch
detaillierte Daten, die es erlauben, die Informationen vieler Geschäftsprozesse als
Ganzes zu analysieren. Diese, zumeist aggregierten, Daten erlauben erst aus der Fülle
der Transaktionsdaten Informationen zu gewinnen. Diese Informationen sind höchst
wertvoll für die Entscheidungsträger eines Unternehmens, da erst diese Informationen
eine fundierte strategische oder taktische Entscheidung ermöglichen. Data Warehousing
hat darüber hinaus die Aufgabe, aus Daten nicht nur Informationen abzuleiten, sondern
diese Informationen in Wissen weiterzuentwickeln und dann in Aktionen zu wandeln.
Mit einem Data Warehouse werden also Unternehmensprozesse (Geschäftsprozesse)
kontrolliert und gesteuert. Somit stellt der Data Warehouse Ansatz den Übergang vom
reinen Datenmanagement hin zur höheren Entwicklungsstufe des
Informationsmanagements dar. [vgl. Martin (1998) S. 11 ff]
„Ein Data Warehouse ist ein umfassendes Konzept zur Entscheidungsunterstützung von
Mitarbeitern aller Bereiche und Ebenen“ [vgl. Stock (2000) S. 51].
Somit hat ein Data Warehouse folgende Merkmale:
•
Orientierung an den unternehmensbestimmenden Sachverhalten
(subjektorientiert):
Typische Subjekte der Betrachtung sind z.B. Kunden, Produkte, Lieferanten.
Man fokussiert inhaltliche Kernbereiche der Organisation.
•
Zeitraumbezug (zeitabhängig):
Es werden Daten benötigt, welche die Entwicklung eines Unternehmens über
einen bestimmten Zeitraum repräsentieren und damit zum Erkennen von Trends
herangezogen werden können. Dies geschieht meist durch Einbindung des
betrachteten Zeitraumes in die entsprechenden Schlüssel der Daten.
•
Struktur- und Formatvereinheitlichung (integriert und vereinheitlicht):
Dieses Merkmal wird erfüllt durch einheitliche Konventionen (bezüglich
Namensgebung, Dateiattributen, etc.), einheitliche Datenformate (z.B.
Werteinheiten) und semantischer Integrität (z.B. Angleichen unterschiedlicher
Kontenrahmen, Währungsumrechnungen, etc.). Ziel ist eine konsistente
Datenmenge im Data Warehouse.
- 47 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
•
Nicht-Volatilität – nur lesender Zugriff (beständig bzw. dauerhaft):
Dauerhafte Speicherung über größere Zeiträume. Die wichtigsten Operationen
sind das Downloaden und die Datenabfrage.
„Derartige Data Warehouse Systeme sind heute nicht als fertiges Produkt verfügbar,
sondern unternehmensindividuell zu konzipieren und zu realisieren, weshalb es
angebracht erscheint, eher von einem Data Warehouse Konzept als von einem Data
Warehouse System zu sprechen“ [vgl. Gabriel/Röhrs (2003) S. 340]. Für eine analoge
Definition der Merkmale des Datawarehouse und auch für zusätzliche Ausführung
verweise ich auf Kemper (1999) S. 458ff, Mertens (2000) S. 20, Schneider/Werner
(2000) S. 526 oder Shaw (2000), S. 502ff.
5.2 ARCHITEKTUR EINES DATAWAREHOUSE
In diesem Abschnitt will ich einen Überblick über die Architektur und die wesentlichen
Komponenten in einem Data Warehouse geben. Dazu wurde eine typische Architektur
im Data Warehouse in Abbildung 15 graphisch dargestellt.
- 48 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 15: Die Architektur eine Data Warehouse
[Quelle: in Anlehnung an Posser/Ossimitz (2001) S. 26]
5.2.1 OPERATIVE DATEN
Das Datawarehouse wird durch eine Reihe von unterschiedlichen operativen
Datenquellen gespeist. Diese individuellen Datenbanken können auf unterschiedlichen
Systemen in unterschiedlichen Formaten vorliegen.
- 49 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
5.2.2 EXTERNE DATENBANKEN
Dies können Datenbanken von externen Anbieter oder frei zugängliche Datenquellen
sein, welche in das Datawarehouse integriert werden.
5.2.3 DIE METADATEN
Meta-Daten enthalten die Aufzeichnungen darüber, wie die operativen Daten aufgebaut
sind, wie die Daten im Data Warehouse aufgebaut sind und wie externe Quellen in das
Data Warehouse integriert werden. Meta-Daten sind Datenbanken, die ein Bestandteil
des Data Warehouse sind. Sie sind vor allem für die Datenbankadministratoren des
Data Warehouse von Bedeutung.
5.2.4 DIE DATENPUMPEN
Datenpumpen (Transaktionsprogramme, Lademanager, Frontend-Komponente) führt
alle mit dem Extrahieren und Laden der Daten in das Data Warehouse verbundenen
Tätigkeiten aus. Dazu gehören einfache Umwandlungen der Daten, um diese für die
Eingabe in das Warehouse vorzubereiten.
5.2.5 DER DATAWAREHOUSE MANAGER
Der Data Warehouse Manager führt alle mit der Verwaltung der Daten im Warehouse
verbundenen Tätigkeiten aus. Dabei ist diese Software insbesondere für folgende
Tätigkeiten zuständig:
•
Analyse der Daten, um die Konsistenz zu gewährleisten
•
Umformen und Zusammenführen von Quelldaten aus der temporären
Speicherung in Data Warehouse Tabellen
•
Erstellen von Indizes und Ansichten der Basistabellen
•
Denormalisierung (falls erforderlich)
•
Aggregatbildung (falls erforderlich)
•
Anlegen von Sicherheitskopien und Archivieren der Daten
[vgl. Connolly et al. (2002) S. 915]
5.2.6 ZUGRIFFSWERKZEUGE FÜR DEN ENDBENUTZER
Der vorrangige Zweck eines Data Warehouse besteht darin, den Benutzern Information
zu liefern, damit sie fundierte Entscheidungen fällen können. Diese Endbenutzer
- 50 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
müssen über Zugriffswerkzeuge mit dem Data Warehouse interagieren können, um die
ad hoc und Routineanalysen effizient zu unterstützen. Anschließend sind diese in fünf
Gruppen eingeteilt, wobei zu bemerken ist, dass es in der Praxis sehr oft zu
Überschneidungen zwischen den Gruppen kommt. [vgl. Connolly et al. S. 916ff]
5.2.6.1
WERKZEUGE FÜR BERICHTE UND ABFRAGEN
Die wichtigsten Werkzeuge für den Benutzer sind diejenigen, die ihm die Informationen
liefern. Es erfolgt die Eingabe einer Benutzeranforderung und eine entsprechende
graphische oder textorientierte Präsentation der Ergebnisse. Üblicherweise werden von
den Anwendungen im Hintergrund SQL-Statements generiert, welche die Informationen
aus dem Data Warehouse abfragen. Zusätzlich ist jedoch zu bemerken, dass diese
Werkzeuge ihre Datenbasis nicht nur aus dem Data Warehouse erhalten, sondern zum
Teil auch Daten aus den operativen Systemen direkt in die Präsentation einbeziehen.
5.2.6.2
WERKZEUGE ZUR ENTWICKLUNG VON ANWENDUNGEN
Da leider sehr oft Standardanwendungsprogramme für individuelle
Benutzeranforderungen ungeeignet sind, gibt es Werkzeuge die Benutzern mit
ausreichender Fachkenntnis erlauben hauseigene Abfrage- und Präsentationstools zu
entwickeln.
5.2.6.3
EXECUTIVE INFORMATION SYSTEM WERKZEUGE (EIS)
Executive Information Systems sind ursprünglich zur Unterstützung strategischer
Entscheidungsfindung auf höchster Ebene entwickelt worden. Sie haben jedoch ihren
Schwerpunkt erweitert und unterstützen jetzt alle Verwaltungsebenen. EIS-Werkzeuge
standen ursprünglich mit Großrechnern in Zusammenhang, die Benutzer in die Lage
versetzten, individualisierte graphische Entscheidungsunterstützungswerkzeuge zu
erstellen, die einen Überblick über die Organisationsdaten und Zugriff auf externe
Datenquellen bereitstellen sollten.
Auf dem heutigen Markt ist die Abgrenzung zwischen EIS-Werkzeugen und anderen
entscheidungsunterstützenden Werkzeugen noch weniger klar, weil EIS-Entwickler
zusätzliche Abfragefähigkeiten einbauen und Anwendungen für Geschäftsbereiche wie
Vertrieb, Marketing und Finanzen liefern. Beispiele für EIS-Werkzeuge sind Lightship
von Pilot Software Inc., Forest and Trees von Platinum Technologies und Express
Analyser von Oracle.
- 51 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
5.2.6.4
DECISION SUPPORT SYSTEME (DSS)
Ein DSS ist ein System, welches für die taktische und strategische
Entscheidungsunterstützung zur Verfügung gestellt wird. Techniken wie Sensibilitätsoder What If Analysen stehen im Vordergrund solcher Anwendungen. Je nach
speziellem Anwendungsgebiet (Liquitätsmanagement, Portfoliomanagement,
Bonitätsprüfung, etc.) werden wieder unterschiedliche Anwendungssysteme entwickelt.
[vgl. Dippold et al. S. 189]
5.2.6.5
ONLINE ANALYTICAL PROCESSING WERKZEUGE (OLAP)
Online Analytical Processing Werkzeuge basieren auf den Konzepten
mehrdimensionaler Datenbanken und erlauben dem erfahrenen Benutzer, die Daten mit
Hilfe komplexer mehrdimensionaler Ansichten zu analysieren. Der Begriff OLAP
wurde von Codd im Jahre 1993 geprägt; er bezeichnete eine Architektur, die komplexe
analytische Anwendungen unterstützt. OLAP Architekturen werden heute mit Hilfe
spezialisierter mehrdimensionaler Datenbanktechnologie, einer eng begrenzten
Datenmenge und einer individuell angepassten Benutzerschnittstelle implementiert.
5.2.6.6
DATA MINING WERKZEUGE
Als Data Mining wird der Prozess bezeichnet, bei dem große Data Warehouses oder
Data Marts durchforstet werden. Dabei wird mit statistischen und mathematischen
Methoden, sowie Methoden der künstlichen Intelligenz operiert und versucht neue
Korrelationen, Muster oder Trends zu entdecken. Data Mining besitzt das Potential, die
Fähigkeiten der OLAP-Werkzeuge abzulösen, da seine Hauptanziehungskraft in der
Fähigkeit liegt, anstelle retrospektiver Modelle vorhersehende Modelle zu erstellen.
Dadurch versucht man durch Data Mining Werkzeuge den Gap zwischen dem reinen
Generieren der Daten und dem Verstehen der selben zu schließen. Dieser Prozess kann
automatisch oder semiautomatisch passieren und sollte einen ökonomischen Vorteil
bringen. [vgl. Witten/Eibe (2000) S. 1ff]
Data Mining Techniken können grundsätzlich in fünf verschiedene Klassen unterteilt
werden:
•
Predictive Modeling:
Man versucht festzustellen, ob einige Felder in der Datenbank auf anderen
Feldern basieren. Dies wird durch Regressionsanalyse bei numerischen Werten
und durch Klassifizierung bei kategorischen Werten versucht.
•
Clustering:
Diese Methode wird auch gelegentlich als “Segmentation“ bezeichnet. Dazu
- 52 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
wird eine Anzahl vom Clustern definiert und die Daten entsprechend
eingeordnet.
•
Data summarization:
Dabei wird versucht die Daten zu summieren, in Gruppen aufzuteilen und zu
analysieren. Ein sehr treffendes Beispiel wäre die KonsumentenwarenkorbAnalyse, wo man zu erkennen versucht, welche Produkte gemeinsam mit
welchen gekauft werden.
•
Dependency modelling:
Man versucht funktionelle Zusammenhänge zwischen den Datenfelder
festzustellen.
•
Change and deviation detection:
Diese Methoden werden für sequenzielle Informationen, wie Zeitreihen oder
genetische Pläne, verwendet.
[vgl. Džeroski/Lavrač (2001) S. 34ff]
5.3 OPERATIVE UND ANALYTISCHE DATEN
In Datenbanksystemen unterscheidet man operative und analytische Datenbanken.
Diese Unterscheidung ist besonders in dem Konnex Data Warehouse eine essentielle.
Operative Datenbanksysteme sind Systeme, die den laufenden Geschäftsbetrieb
(Transaktionsdaten) erfassen und verwalten. Diese werden auch als Online Transaction
Processing (OLTP) Datenbanksysteme bezeichnet. Operative Daten sind
unübersichtlich, weil sie eine Vielfalt von Details unterschiedlicher Anwendungen
enthalten. In analytischen Datenbanksystemen werden umfangreiche Auszüge aus
operativen Daten periodenweise erzeugt und entweder zusammengefasst (aggregiert)
oder detailliert zur flexiblen Analyse bereitgestellt. Deshalb enthalten analytische
Systeme im Gegensatz zu operativen Systemen auch historische Daten. [vgl. Lusti,
Markus (1999), S. 123 ff]
Eigenschaften
Operative Daten
Data Warehouse
Prozess
transaktionsintensiv
abfrageintensiv
Benutzer
große Anzahl
relativ geringe Anzahl
Umfang
meist nur aktuelle Daten
aktuelle und historische
Daten
ständig aktualisiert
sporadisch aktualisiert
Aktualisierung
- 53 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
funktionell
subjektorientiert und
verdichtet
normal
systemabhängig
Datenbanksystem
Daten werden regelmäßig
aktualisiert
intervallweise Aktualisierung
der Daten
Datenmodel
Daten sind normalisiert,
Modellierung aufgrund der
Transaktionen
Daten sind nicht normalisiert,
Modellierung aufgrund der
Dimensionen des Subjektes
Anwendungsbereich
definiert durch den Bereich
der operativen
Transaktionsanwendung
(statisch, detailliert)
liefert ein flexibles,
erweiterbares EntscheidungsUnterstützungsinstrument
(flexibel, aggregiert)
Entwicklung
meist werden OLTP-Systeme
eingesetzt
Data Warehouse wird
wiederholt erzeugt und
entwickelt
Zuordnung
eindeutige Prozesshierarchie
der Benutzer zuordenbar
komplexe Benutzerhierarchie
unterschiedlicher
Entscheidungsebenen
Hohe Verfügbarkeit
geringe Verfügbarkeit
Identifikationskriterium
eindimensional
mehrdimensional
Datenmanipulation
zeilenbezogen /
aktualisierend
sichtspezifisch / analysierend
Integration
Datenqualität
Verfügbarkeit
Tabelle 3: Vergleich operative Daten und Data Warehouse [in Anlehnung: Connolly et al. (2002) S.
910; Prosser, Ossimitz (2000 a), S. 11]
- 54 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
5.4 AUFBAUEN UND AKTUALISIEREN EINES DATAWAREHOUSE
AUS DEN DATENQUELLEN
5.4.1 KLASSISCHE VORGEHENSWEISE BEIM AUFBAUEN UND
AKTUALISIEREN EINES DATAWAREHOUSE
Der Aufbau eines Data Warehouse beginnt mit einer Auswahl der geeigneten Attribute
aus den operativen Datenbanksystemen. Zusätzlich werden diese meist durch
Informationen aus unternehmensexternen Quellen, z. B. Anbieter von
Marktforschungsergebnissen, ergänzt. Sowohl externe, als auch interne Daten werden
vor ihrer Integration in ein Data Warehouse transformiert. Dabei werden zuerst die
Daten ohne Veränderungen direkt aus den operationalen und externen Datenquellen
kopiert. In einem weiteren Schritt wird Irrelevantes weggelassen, Neues hinzugefügt
und Bestehendes umgeordnet oder verdichtet. Die Daten liegen dann in einer so
genannten Basisfaktentabelle (BFT) vor. Dieser Vorgang wird durch sogenannte
Datenpumpen (siehe 5.2.4) durchgeführt. Das Durchsuchen einer Basisfaktentabelle mit
vielen Einträgen kostet allerdings Zeit und kann auch nicht beliebig beschleunigt
werden. Daher werden in einem Data Warehouse meist vorgefertigte Aggregate
hinterlegt. Diese werden in wenig und stark zusammengefasste Daten unterteilt [vgl.
Connolly et al. (2002) S. 915f]. Diese aggregierten, zusammengefassten Daten können mit
dem Synonym des materialisierten View bezeichnet werden.
Transformationen, die Aufnahme historischer und externer Daten, sowie die
gleichzeitige Haltung von Detaildaten und Aggregaten führen dazu, dass analytische
Datenbanken in der Regel größer werden als ihre operativen Quellen. Wie und in
welcher Art und Weise die operativen Daten verändert, aggregiert oder umgeordnet
werden, ist abhängig vom konzeptionellen Modell des Data Warehouse, welches sich
wiederum aus den Benutzeranforderungen ergibt.
5.4.2 NEUE ANSÄTZE FÜR DAS AUFBAUEN UND AKTUALISIEREN DER
MATERIALISIERTEN SICHTEN
Eine Datawarehouse enthält große Mengen an Information, welche aus
unterschiedlichen Datenquellen stammt. Üblicherweise werden die Daten im
Warehouse mit den Daten in den Datenquellen in regelmäßigen Intervallen aktualisiert
und die neuen Aggregate erzeugt und gespeichert. Allerdings ist das Zeitfenster für das
Aktualisieren beschränkt. Deshalb gibt es unterschiedlichste Ansätze dieses Problem zu
lösen oder zu umgehen.
- 55 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
5.4.2.1
DER WHIPS PROTOTYP
Der Ansatz der WHIPS (Warehousing Information Project at Stanford), welcher an der
Stanford University entwickelt wurde, geht von der in Abbildung 16 angeführten
Struktur aus. Dabei werden als die Hauptkomponenten des Warehouse die „Data
Querying & Analysis“ Komponente, verantwortlich für die Erfüllung der
Informationsbedürfnisse der Benutzer und die „Data Integration“ Komponente, welche
für die Datensammlung und die Erzeugung der materialisierten Sichten verantwortlich
ist, angeführt. Diese zwei Komponenten können nicht unabhängig voneinander gesehen
werden. So basiert die Auswahl der materialisierten Sichten, welche durch den Data
Integrator materialisiert werden, auf den erwarteten Bedürfnissen der Benutzer.
Abbildung 16: Die Basisarchitektur des WHIPS Systems [Quelle: Labio et al. (1997) S. 557]
In Abbildung 17 wird die Data Integration Komponenten näher beleuchtet. Dabei wurde
in Stanford jedes Modul als CORBA Objekt implementiert. Das relationale Modell
wurde für das Warehouse verwendet.
- 56 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 17: Die WHIPS System Architektur für Warehouse Maintenance [Quelle: Labio et at
(1997) S. 558]
Jede Quelle hat einen Wrapper und einen Monitor. Der Monitor hat die Aufgabe die
Datenquelle zu überwachen und bei Änderungen in der Basisdatenquelle den Integrator
darüber in Kenntnis zu setzen. In Stanford wurden triggerbasierende Monitore für die
relationalen Datenquellen und Snapshot Monitore für andere Datenquellen, wo nur
periodische Aktualisierungen möglich sind, eingesetzt. Der Wrapper hat die Aufgabe
die Abfragen der unterschiedlichen Datenquellen zu übersetzen. Stellt also der Query
Processor eine Anfrage an einen Wrapper, übersetzt er diese Query entsprechend der
zugrunde liegenden Datenquelle. Die zentrale Rolle hat der Integrator inne. Er erhält die
Änderungsmeldungen der Monitore, weiß welche Querys von den gemeldeten
Datenquellen betroffen sind und benachrichtigt die entsprechenden View Manager die
betroffenen materialisierten Sichten, bzw. Tupel im Data Warehouse zu aktualisieren.
Die View Manager senden ihre Information an einen Wrapper, welcher die Daten in das
Format der Data Warehouse Tabellen wandelt und speichert. [vgl. Labio et al. (1997) S.
557ff]
- 57 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
5.4.2.2
DER SUMMARY TABLE ANSATZ
Materialisierte Sichten in einem Data Warehouse können grundsätzlich auf zwei Arten
aktualisiert werden. Entweder man erzeugt den materialisierten View komplett neu oder
man arbeitet die Änderungen seit dem letzten Updatevorgang ein. Mumick et al. (1997)
unterteilen dazu den Updatevorgang in einen Propagate Vorgang und einen Refresh
Vorgang.
Beim Propagate Vorgang werden so genannte Summary-Delta Tables erzeugt. Diese
Tables enthalten alle Änderungen, welche sich seit dem letzten Updatevorgang ergeben
haben. Man unterscheidet zwei Tables:
•
Den Pos_ins Table, welcher die neuen, bzw. veränderten Tupel des BFT enthält
und
•
den Pos_del Table, welcher alle gelöschten Tupel enthält, welche aus dem BFT
entfernt werden müssen.
Beim Refresh Vorgang werden nun diese Änderungen der Delta-Summary Tables in die
eigentlichen materialisierten Views geschrieben. Der Vorteil dieser Methode ist, dass
während des Propagate Vorganges das Datawarehouse uneingeschränkt zur Verfügung
steht, da die Abfragetabellen nicht berührt werden. Erst beim Refresh Vorgang ist das
Warehouse nicht verfügbar. Dadurch kann die Gesamtzeit der Nichtverfügbarkeit
deutlich gesenkt werden.
Die Delta-Summary Methode funktioniert aber bei verschiedenen Aggregaten
unterschiedlich. Mumick et al. (1997) unterscheiden grundsätzlich drei Klassen von
Aggregaten:
•
Distributive (SQL Funktionen COUNT, SUM, MIN und MAX)
•
Algebraic (SQL Funktion AVG) und
•
Holistic (Median, …)
Ein Nachteil der Delta-Summary Methode ist die Tatsache, dass nur distributive
Funktionen verarbeitet werden können. Holistische Funktionen können grundsätzlich
nicht verarbeitet werden. Algebraische Funktionen können zum Teil simuliert werden
indem z.B. der Mittelwert aus Summe durch Anzahl berechnet wird (SUM/COUNT).
Auch die Funktionen MIN und MAX sind nur eingeschränkt einsetzbar. Sollte z.B. das
aktuelle MIN oder MAX Tupel in der Menge der gelöschten Tupel sein, ist es nicht
möglich das neue MIN oder MAX Tupel zu bestimmen ohne den gesamten Table neu
zu erzeugen. Dies kann zwar durch einen Algorithmus automatisiert werden, vermindert
- 58 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
jedoch den Zeitgewinn, welcher durch die Delta-Summary Methode erzielt werden
könnte.
prepare-insertions
prepare-deletions
1
-1
case when expr is null then case when expr is null then
COUNT(expr)
0 else 1
0 else -1
-expr
SUM(expr)
expr
MIN(expr)
expr
expr
MAX(expr)
expr
expr
COUNT(*)
Tabelle 4: Änderungen der Aggregate nach Funktionen [Quelle: Mumick et al. (1997) S.105]
In Tabelle 4 sind die Änderungen der Aggregattabellen abhängig von den jeweiligen
Funktionen aufgelistet. Wird z.B. der Wert 10 im Delta Summary Insert Table
errechnet, wird dieser Wert zum materialisierten View addiert. Wird z.B. der Wert 10
im Delta Summary Delete Table errechnet, wird dieser Wert vom materialisierten View
subtrahiert. [vgl. Mumick et al. (1997) S.100ff]
5.4.2.3
DER MULTIPLE VIEW MAINTENANCE POLICIES ANSATZ
Dieser Ansatz berücksichtigt, dass die Quelldaten, aus welchen die Daten importiert
werden, sehr unterschiedlich sein können. Durch diese unterschiedliche Behandlung der
materialisierten Views soll ein Perfomancegewinn erzielt werden. Dabei werden die
Views in drei unterschiedliche Klassen eingeteilt:
•
Immediate Views: Diese können ständig aktualisiert werden, sobald sich eine
Quelldatenbank, bzw. ein Quelldatensatz ändert.
•
Deferred Views: Diese Views werden bei Anfrage des Users materialisiert. Das
führt zu langsameren Abfragen, aber schnelleren Update Vorgängen.
•
Snapshot Views: Diese werden periodisch durch einen asynchronischen Prozess
aktualisiert. Dadurch ist die Aktualität der Daten nicht garantiert.
Diese unterschiedlichsten Views können wiederum in Viewgroups zusammengefasst
werden. Diese Viewgroups von Colby et al. (1997) sind definiert dass
•
die Aktualisierung eines Views in einer Viewgroup keine Aktualisierungen
in einer anderen Viewgroup auslöst
- 59 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
•
es möglich sein muss, eine Query abzufragen ohne einen Join mit einem
Table außerhalb der Viewgroup zu machen.
[vgl. Colby et al. (1997) S.405ff]
5.5 INFORMATIONSFLÜSSE IN EINEM DATA WAREHOUSE
Connoly et al. (2002) teilen die Informationsflüsse in einem Data Warehouse in fünf
primäre Informationsflüsse:
Prozess
Inflow
Upflow
Downflow
Outflow
Metaflow
Beschreibung
Extrahieren, Laden und Reinigen der Quelldaten
Erhöhen des Wertes der Daten im Warehouse durch
Zusammenfassen, Verpacken und Verteilung
Archivieren und Sichern der Daten im Warehouse
Die Daten für Endbenutzer verfügbar machen
Verwalten der Metadaten
Tabelle 5: Informationsflüsse im Data Warehouse [Quelle: Connolly et al. (2002) S. 918ff]
5.5.1 INFLOW
Der Inflow befasst sich damit, Daten aus den Quellsystemen zu übernehmen, die in das
Data Warehouse geladen werden sollen. Da die Quelldaten überwiegend durch OLTP
Systeme erzeugt werden, müssen sie für den Zweck des Data Warehouse neu aufgebaut
werden. Dazu gehört Folgendes:
•
Reinigen der „verunreinigten“ Daten.
•
Neustrukturieren der Daten. Zum Beispiel durch Hinzufügen und/oder Löschen
von Feldern und Denormalisierung.
•
Gewährleisten, dass die Quelldaten in sich und mit den bereits im Data
Warehouse befindlichen Daten konsistent sind.
Um den Inflow effizent zu verwalten, müssen Mechanismen festgelegt werden, um zu
ermitteln, wann man mit dem Extrahieren der Daten beginnt, die erforderlichen
Umwandlungen ausführt und Konsistenzprüfungen vornimmt. Beim Extrahieren der
Daten aus dem Quellsystem muss man unbedingt dafür sorgen, dass sich die Daten in
einem konsistenten Zustand befinden, um eine konsistente Ansicht der Firmendaten zu
bekommen. Die Datenextraktionssoftware sollte vollständig automatisch funktionieren
und in der Lage sein, das Auftreten von Problemen und Fehlern zu melden.
- 60 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
5.5.2 UPFLOW
Mit dem Upflow sind folgende Aktivitäten verknüpft:
•
Zusammenfassen der Daten durch Auswahl, Projezieren, Verknüpfen und
Gruppieren relationaler Daten zu Ansichten, die für den Endbenutzer bequemer
und hilfreicher sind. Das Zusammenfassen geht über einfache relationale
Operationen hinaus - es umfasst ausgefeilte statistische Analysen einschließlich
der Feststellung von Trends, der Clusterbildung und des Sampling.
•
Verpacken der Daten durch Konvertieren der zusammengefassten oder
detaillierten Daten in sinnvollere Formen wie zum Beispiel Arbeitsblätter,
Textdokumente, Diagramme oder Animationen.
•
Verteilung der Daten an geeignete Gruppen, um ihre Verfügbarkeit und
Zugänglichkeit zu erhöhen.
5.5.3 DOWNFLOW
Die Archivierung alter Daten spielt bei der Aufrechterhaltung von Effizenz und
Leistung des Data Warehouse durch Auslagern der älteren Daten eine wichtige Rolle.
Der Informations-Downflow umfasst die Prozesse, welche sicherstellen, dass der
aktuelle Zustand des Data Warehouse nach Datenverlust oder Soft- bzw.
Hardwarefehlern wieder hergestellt werden kann.
5.5.4 OUTFLOW
Der Outflow ist die Stelle, an der die Organisation den wirklichen Wert des Data
Warehouse wahrnimmt. Zum Outflow gehören folgende Schlüsselaktivitäten:
•
Das Zugreifen, das sich mit der Erfüllung der Anforderungen der Endbenutzer
hinsichtlich der benötigten Daten befasst.
•
Das Übermitteln, das sich mit der aktiven Übermittlung der Information an die
Rechner der Endbenutzer beschäftigt. Dies kann von periodischen Reports bis zu
Veröffentlichungs- und Abonnementsprozessen reichen.
5.5.5 METAFLOW
Der Metaflow ist der Prozess, welcher Metadaten bewegt. Also Daten über die anderen
Informationsflüsse. Um den sich ändernden Geschäftsbedürfnissen gerecht zu werden,
ändern sich herkömmliche Systeme ständig. Der Metaflow muss sich deshalb
fortlaufend mit diesen Änderungen befassen.
- 61 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
5.6 PROBLEME IM DATA WAREHOUSE
•
Unterschätzen der Ressourcen für das Laden der Daten
Viele Entwickler unterschätzen die für das Extrahieren, Reinigen und Laden
der Daten in das Warehouse erforderliche Zeit, die bis zu 80% der
Gesamtentwicklungszeit ausmachen kann, obwohl bessere Datenreinigungsund Datenverwaltungswerkzeuge diese Zeit reduzieren könnten.
•
Unentdeckte Probleme mit Quellsystemen
Unentdeckte Probleme im Zusammenhang mit den Quellsystemen, die das
Data Warehouse speisen, werden irgendwann aufgedeckt, möglicherweise
erst nach Jahren. Der Entwickler muss entscheiden, ob sie innerhalb des
Data Warehouse und/oder in den Quellsystemen behoben werden sollen.
Beim Eingeben der Einzelheiten können einige Felder beispielsweise eine
NULL zulassen, was dazu führen kann, dass Mitarbeiter unvollständige
Daten eingeben, obwohl diese verfügbar und geeignet sind.
•
Fehlende Aufzeichnungen der erforderlichen Daten
Warehouse-Projekte zeigen häufig Bedarf für Daten, die in den bestehenden
Quellsystemen nicht aufgezeichnet wurden. Die Organisation muss
entscheiden, ob die operativen Systeme geändert werden oder ein System für
die Aufzeichnung der fehlenden Information erstellt werden soll.
•
Gestiegener Bedarf für Endbenutzer
Nachdem die Endbenutzer Abfrage- und Berichtswerkzeuge bekommen
haben, kann die Anforderung von Unterstützung durch die für Dienste
zuständigen Mitarbeiter steigen statt sinken. Das liegt am wachsenden
Wissen der Benutzer über die Fähigkeiten und den Wert des Data
Warehouse.
•
Datenhomogenisierung
Data Warehousing in großen Umfang kann enorme Anforderung in Bezug
auf die Datenhomogenisierung haben. Insbesondere ist darauf zu achten die
Daten durch die Homogenisierung nicht zu verfälschen.
•
Hoher Ressourcenbedarf
Das Data Warehouse kann viel Speicherplatz auf der Festplatte belegen.
•
Datenbesitz
Sensible Daten sollten auch nach der Implementierung eines Data
Warehouse nur gewissen Benutzern zugänglich sein.
- 62 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
•
Hoher Pflegeaufwand
Data Warehouses sind Systeme mit hohem Pflegeaufwand, die oft in
Kostenkalkulationen einen erheblichen Posten einnehmen können.
•
Projekte mit langer Dauer
Der Aufbau eines Warehouse kann bis zu drei Jahre dauern. Dies wird oft
unterschätzt und verursacht Komplikationen.
•
Komplexität der Integration
Komplexe Unternehmensstrukturen führen zu komplexen Data Warehouse
Systemen. Das stellt Entwickler oft vor unübersichtliche und nahezu
unlösbare Fragestellungen.
[vgl. Connolly et al. S. 912f]
5.7 VORTEILE EINES DATAWAREHOUSE
Als Vorteile eines effizienten und effektiven Informationsmanagements durch ein
Datawarehouse lassen sich nach Fritz (1997) folgende Punkte herausstellen:
•
Reduzierung der Kosten für Entscheidungsprozesse:
Durch Automatisierung der Datenbeschaffung und Datenkonsolidierung lassen
sich redundante Informationsbeschaffung und langwierige Diskussionen über
inkonsistente oder inkompatible Daten vermeiden. Gleichzeitig genügt es, den
Mitarbeitern eine einzige Quelle für die Generierung von
Managementinformationen zur Verfügung zu stellen.
•
Verbesserung der Qualität der Information:
Durch die zentrale Speicherung von Daten aus unterschiedlichsten internen und
externen Quellen wird es möglich, umfangreiche Analysen durchzuführen.
Bisher nicht bekannte Zusammenhänge werden durch eine Integration der Data
Mining Verfahren aufgedeckt.
•
Flexibilität der Informationsgewinnung:
Neue Führungsinformationssysteme, die Data Warehouse- und Data MiningKonzepte verbinden, können den Bedarf an Führungsinformationen besser
befriedigen, denn sie sind auf die interaktive Informationsgewinnung ausgelegt
und erleichtern die Interpretation der Daten. Im Gegensatz zu vorgefertigten
Reports, wie sie von klassischen Management-Informationssystemen generiert
wurden, bieten sie anwenderfreundliche, interaktive Analysemöglichkeiten.
[vgl. Fritz (1997) S. 2]
- 63 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
5.8 ANFORDERUNGEN AN EIN DATENBANKSYSTEM FÜR EIN
DATAWAREHOUSE
Die speziellen Anforderungen an ein für Data Warehousing geeignetes relationales
Datenbanksystem sind nach Connolly et al. (2002):
•
Ladeleistung:
Data Warehouses erfordern das regelmäßige inkrementelle Laden neuer Daten in
engen Zeitfenstern. Die Leistung des Ladeprozesses sollte in hundert Millionen
Zeilen oder in Gigabyte pro Sekunde gemessen werden, und das Geschäft sollte
nicht durch eine Obergrenze eingeschränkt werden.
•
Ladeverarbeitung:
Zum Laden neuer oder aktualisierter Daten in das Data Warehouse sind viele
Schritte erforderlich: Datenkonvertierung, Filterung, Neuformatierung,
Integritätsprüfung, physische Speicherung, Indizierung und Aktualisierung der
Metadaten. Obwohl jeder Schritt in der Praxis atomar sein mag, sollte der
Ladeprozess als geschlossene, nahtlose Arbeitseinheit erscheinen.
•
Sicherung der Datenqualität:
Die Verlagerung auf faktenbasierte Verwaltung verlangt höchste Datenqualität.
Das Warehouse muss trotz „unsauberer“ Quellen und gewaltiger
Datenbankgrößen lokale und globale Konsistenz sowie referenzielle Integrität
gewährleisten. Laden und Vorbereiten sind zwar notwendige Schritte, reichen
aber nicht aus. Die Fähigkeit, die Abfragen der Endbenutzer zu beantworten,
bildet den Erfolgsmaßstab einer Data Warehouse Anwendung. Mit der
Beantwortung einer größeren Menge von Fragen neigen die Analysten dazu,
kreative und komplexere Fragen zu stellen.
•
Abfrageleistung:
Faktenbasierte Verwaltung und Ad-hoc-Analyse dürfen durch die Leistung des
relationalen Data Warehouse Datenbanksystems weder gebremst noch
verhindert werden. Umfangreiche, komplexe Abfragen für geschäftliche
Schlüsseloperationen müssen in einem vernünftigen Zeitraum abgeschlossen
werden.
•
Terabyte-Skalierbarkeit:
Die Größe von Data Warehouse steigt enorm; sie beginnt bei wenigen oder
mehreren hundert Gigabyte und erreicht mehrere Terabyte (1012 Byte) oder
Perabyte (1015 Byte). Das relationale Datenbanksystem darf keine
architekturbedingten Einschränkungen der Datenbankgröße aufweisen und sollte
modulare und parallele Verwaltung unterstützen. Falls ein Fehler auftritt, sollte
- 64 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
es fortlaufende Verfügbarkeit gewährleisten und Mechanismen für die
Wiederherstellung bieten. Es muss Massenspeichergeräte wie optische Platten
und Geräte zur hierarchischen Speicherverwaltung unterstützen. Die
Abfrageleistung sollte schließlich nicht von der Größe der Datenbank, sondern
von der Komplexität der Abfrage abhängen.
•
Benutzermengen-Skalierbarkeit:
Das derzeitige Denken geht dahin, dass der Zugriff auf ein Data Warehouse auf
relativ wenige Benutzer aus der Geschäftsleitung beschränkt ist. Das wird
angesichts der Erkenntnis des Nutzens von Data Warehouses wahrscheinlich
nicht so bleiben. Es lässt sich vorhersehen, dass das relationale
Datenbanksystem für das Data Warehouse in Zukunft in der Lage sein sollte,
mehrere hundert oder sogar tausend Benutzer zu verkraften und gleichzeitig eine
akzeptable Abfrageleistung beizubehalten.
•
Das vernetzte Data Warehouse:
Data Warehouse-Systeme sollten zur Zusammenarbeit in einem
umfangreicheren Data Warehouse-Netzwerk fähig sein. Das Data Warehouse
muss Werkzeuge zur Koordination der Bewegung von Datenteilmengen
zwischen den Warehouses besitzen. Die Benutzer sollten von einer einzelnen
Client-Workstation aus Einblick in mehrere Data Warehouses haben und mit
diesen arbeiten können.
•
Warehouse-Administration:
Der sehr große Umfang und die zeitzyklische Natur des Data Warehouse
verlangt einfache und flexible Administration. Das relationale Datenbanksystem
muss Steuerelemente besitzen, um Ressourcengrenzen, eine
Rückbelastungskontierung (zur Zuweisung von Kosten an die Benutzer) und das
Setzen von Prioritäten für Abfragen (zur Erfüllung der Bedürfnisse
unterschiedlicher Benutzerklassen und Aktivitäten) implementieren zu können.
Außerdem muss es die Verfolgung der Arbeitsbelastung und die
Feinabstimmung vorsehen, damit sich die Systemressourcen auf maximale
Leistung und maximalen Durchsatz optimieren lassen. Der am deutlichsten
sicht- und messbare Wert für die Implementierung eines Data Warehouse zeigt
sich im unbehinderten, kreativen Zugriff auf die Daten.
•
Integrierte dimensionale Analyse:
Die Leistungsfähigkeit mehrdimensionaler Ansichten ist weithin akzeptiert, und
um die höchstmögliche Leistung für relationale OLAP-Werkzeuge
bereitzustellen, muss im relationalen Datenbanksystem des Warehouse
dimensionale Unterstützung gegeben sein. Das Datenbanksystem muss das
- 65 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
schnelle und einfache Erstellen im voraus berechneter Zusammenfassungen
unterstützen, die in umfangreichen Data Warehouses üblich sind und
Pflegewerkzeuge zur Automatisierung der Erstellung dieser Aggregatwerte
bereitstellen. Die dynamische Berechnung von Aggregatwerten sollte mit den
interaktiven Leistungsbedürfnissen des Endbenutzers übereinstimmen.
•
Erweiterte Abfragefunktionalität:
Die Endbenutzer verlangen erweiterte analytische Berechnungen, sequenzielle
und vergleichende Analysen und konsistenten Zugriff auf detaillierte und
zusammengefasste Daten. Die Verwendung von SQL kann in einer
Client/Server-Umgebung mit „Zeig-und-klick“-Werkzeugen wegen der
Komplexität der Benutzerabfragen manchmal unpraktisch oder sogar unmöglich
sein. Das relationale Datenbanksystem muss einen vollständigen und erweiterten
Satz analytischer Operationen zur Verfügung stellen.
[vgl. Connolly et al. (2002) S. 922f]
5.9 DATA MARTS
Zeitgleich mit dem Aufkommen der Data Warehouses entstand auch das verwandte
Konzept der Data Marts. Ein Data Mart ist eine Teilmenge eines Data Warehouses,
welche die Bedürfnisse einer bestimmten Abteilung oder Geschäftsfunktion erfüllt. Ein
Data Mart enthält diese Teilmenge der Daten normalerweise in Form von
zusammengefassten Informationen über eine bestimmte Abteilung oder
Geschäftsfunktion. Der Data Mart kann selbständig oder zentral mit dem Data
Warehouse verknüpft sein.
Data Warehouses und Data Marts unterscheiden sich durch folgende Merkmale:
•
Ein Data Mart konzentriert sich ausschließlich auf die Bedürfnisse von
Benutzern, die mit einer Abteilung oder Geschäftsfunktion zu tun haben.
•
Data Marts enthalten normalerweise im Unterschied zu Data Warehouses keine
detaillierten operativen Daten.
•
Da Data Marts im Vergleich mit Data Warehouses weniger Information
enthalten, sind sie einfacher zu verstehen, und man kann sich in ihnen leichter
bewegen.
[vgl. Connolly et al. (2002) S. 927f]
- 66 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
5.10 DIE MODELLIERUNG EINES DATAWAREHOUSE
5.10.1
MODELLTHEORIE
Bei der Modellierung wird aus einem Problembereich, dem Original, durch Abbilden,
Verkürzen und Vereinfachen mit einer gegebenen Pragmatik ein Modell gebildet. Man
unterscheidet isomorphe (ohne Informationsverlust) und homomorphe (mit
Informationsverlust) Abbildung von realen Systemen.
Das Metamodell ist kein Modell eines Modells, sondern ein Modell eines
Modellbereichs, d.h. einer Menge gleichartiger, nach der gleichen Technik erstellter
Modelle. [vgl. Kaiser (2000)]
Abbildung 18: Das Modellsystem [Quelle: Kaiser (2000)]
Man unterscheidet drei Phasen der Modellierung:
•
Konzeptionelles Modell: z.B. Entity Relationsmodell, Dimensional Fact (DF)
Modell
•
Umsetzung in ein logisches Modell: z.B. relationales Modell , Star Schema
•
Physischer Entwurf: Implementierung des konkreten Modells
In jeder Phase der Modellierung stehen den Entwicklern unterschiedlichste Werkzeuge
zur Verfügung.
- 67 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 19: Phasen der Modellierung [Quelle: Kaiser (2000)]
5.10.2
ATTRIBUTE
Attribute stellen die Grundeinheiten für die Analyse dar. Attribute entsprechen in einer
relationalen Datenbank den Spalten. Typische Attribute eines Kunden wären z.B.
Kundennummer, Anrede, Name, Adresse, usw. In einem Data Warehouse unterscheidet
man 3 Typen von Attributen:
•
Hierarchiestufen: Identifizieren ein Aggregationslevel (z.B. Kundengruppe,
Region, Staat, usw.).
•
Schlüsselfelder, Indikator, „Fact-Attribute“: Sind Attribute, die aggregiert
werden können (z.B. Umsatz, Stück, Liter, Kilogramm, usw.).
•
Nicht-aggregierbare Attribute: Sind Attribute, die zusätzliche Informationen
geben (z.B. Name des Kunden, Adresse des Kunden, usw.).
5.10.3
DIMENSIONEN UND HIERARCHIEN
Die Dimension bestimmt die Granularität der . Sie ist ein meist symbolisches und
diskretes Attribut, das die Auswahl, Zusammenfassung und Navigation eines
Schlüsselfeldes erlaubt. Jede Dimension hat mindestens eine Hierarchiestufe. Man
spricht von der Skalierbarkeit der Dimensionen (z.B. Tag, Monat, Jahr). Zu jeder
Hierarchiestufe existiert eine konkrete Ausprägung (z.B. Staat, Land, Bezirk, Ort,
- 68 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Strasse) und damit kann man für jede Hierarchiestufe eine Aggregation der Facts
vornehmen (z.B. Umsatz pro Bezirk, Umsatz pro Ort, usw.).
Abbildung 20: Einfache Hierarchie am Beispiel eines Kunden
Die Zeit ist eine Dimension, die immer in jedem Data Warehousesystem vorkommt.
Systeme mit mehr als zwei Dimensionen nennt man multidimensionale Systeme.
Dimensionen und Hierarchien können relativ übersichtlich allgemein formal in der
Notation d yx dargestellt werden. Wobei y im Intervall 0 → ∞ liegt und die Dimension
repräsentiert. Die Variable x im Intervall 0 → ∞ gibt die Hierarchiestufe wieder. So
stellt z.B. das Element d 32 die 3 Hierarchiestufe der Dimension 4 dar.
5.10.4
DIE DATENWÜRFEL
Bei der Kombination von zwei Dimensionen entsteht eine klassische Tabelle, wie sie
von dem relationalen Datenmodell her bekannt ist. Durch das Hinzufügen einer dritten
Dimension entsteht ein dreidimensionaler Raum, der typischerweise in der Form eines
Würfels (cube) modelliert wird. Jede Kante des Würfels bildet eine Dimension ab (siehe
Abbildung 21) und ist durch deren Elemente in ihrer Länge fest skaliert. Wenn mehr als
3 Dimensionen verwendet werden, spricht man auch von einem Hyper-Würfel
(hypercube). Dabei ist zwar das geometrische Vorstellungsvermögen erschöpft,
gedanklich aber sind mehr als dreidimensionale Kombinationen problemlos
nachzuvollziehen, wenn die darin enthaltenen Dimensionen den realen Datenstrukturen
entsprechen. Mathematisch kann ein Würfel mit n Dimensionen auch als Vektor (v) mit
n Elementen aufgefasst werden, wobei jedes Element des Vektors einer Hierarchiestufe
einer Dimension entspricht.
- 69 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 21: Darstellung eines Würfels (cube) mit den Dimensionen Zeit, Artikel und Kunden [ in
Anlehnung: Prosser/Ossimitz (2000), S. 18]
5.10.5
OPERATOREN
Würfel entstehen durch die Kombination von Dimensionen und deren Ausprägungen
(Hierarchiestufen). Mögliche Inhalte ergeben sich aus dem Kartesischen Produkt der
Hierarchiestufen . Bei z.B. 1000 Kunden und 5 Jahren über alle Artikel (Würfel X)
erhält man 5000 mögliche Einträge für diesen Würfel. Diese Einträge enthalten die
aggregierten Werte der Schlüsselfelder oder Facts (z.B. Summe Umsatz/Kunden und
Jahr für alle Artikel). Es gibt aber neben der Summe noch eine Reihe andere
Operatoren, die in Tabelle 6 kurz darstellt sind.
Operator
Sum
Average
Minimum
Maximum
Nominal
NO
NO
NO
NO
Ordinal
NO
(YES)
YES
YES
Interval
NO
YES
YES
YES
Rational
YES
YES
YES
YES
Tabelle 6: Operatoren und Zahlentypen [in Anlehnung: Prosser, Ossimitz (2000 a), S. 20]
Nominale Kennzahlen sind durch Zahlen dargestellte Codewerte, wie etwa das
Geschlecht oder klassische True-or-False-Aussagen (0 für männlich, 1 für weiblich).
Diese Kennzahlen können nicht aggregiert werden und sind für Key Figures ungeeignet.
- 70 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Ordinale Zahlentypen sind klassischerweise Ratings, wie etwa ein Schulnotensystem
oder die Bewertung von Meinungsforschungsumfragen. Durch die ordinalen
Kennzahlen wird nur eine Reihenfolge ausgedrückt, es wird jedoch keine Aussage über
die Differenz zwischen den Werten gegeben. Deshalb kann normalerweise kein
Mittelwert gebildet werden, obwohl das beim Schulnotensystem mit einer Kombination
der Schulnoten mit einem gewissen Prozentsatz an richtigen Antworten zum Teil
möglich ist. Intervallkennzahlen und Rationalkennzahlen sind beide metrisch. Der
Unterschied liegt darin, dass Intervallkennzahlen einen Nullpunkt besitzen. Als
bekanntestes Beispiel ist hier die Temperatur zu nennen. [vgl. Prosser/Ossimitz (2003) S. 32]
5.10.6
SLICE AND DICE
OLAP-Systeme bieten Anwendern individuelle und flexible Sichten auf „ihre“, für sie,
interessanten Daten. Dies wird durch Isolieren einzelner Schichten aus dem gesamten
Datenpool vollzogen. Slice beschreibt dabei das „Schneiden“ eines bestimmten
Ausschnitts (etwa einer Periode) aus der Zeitdimension, wodurch der betrachtete
Datenwürfel neu determiniert wird. Zum anderen besteht die Möglichkeit, diesen
Würfel von verschiedenen Seiten zu betrachten. So erhält der Anwender durch
„Drehen“, „Kippen“ oder „Würfeln“ (Dice) jeweils eine neue Perspektive. Mit Slice
und Dice werden die Anwender bei typischen Geschäftsfragen unterstützt. (z.B. Welche
Kunden im Burgenland haben einen Umsatz über 100 000 ?). [vgl. Schinzer et al. (1997), S.
40 ]
Abbildung 22: Selektion der Daten durch das Slice-Verfahren [Quelle: Schinzer et al. (1997), S. 40]
- 71 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Die Abbildung 22 stellt deutlich die verschiedenen Möglichkeiten des Slice Verfahrens
dar. Man sieht, dass unterschiedliche Anwender unterschiedliche Sichtweisen auf das
Datenmodell benötigen.
5.10.7
NAVIGATION DURCH DEN DATENBESTAND
Beim Navigieren durch den Datenbestand unterscheidet man wie in Abbildung 23
angeführt folgende Möglichkeiten:
•
Drill Down: Die Möglichkeit von hoch aggregierten Kennzahlen auf niedrigere
Aggregationsstufen zu wechseln, um so zusätzliche Detailinformationen zu
erhalten.
•
Roll up: Die Möglichkeit Kennzahlen niedriger Aggregationsstufe weiter zu
aggregieren.
•
Drill Across (Drill Through): Die Möglichkeit bei einem beliebigen Schnitt
durch den Datenwürfel auch die benachbarten Dimensionselemente (z.B. andere
Region, anderer Kunden, anderes Produkt) zu betrachten.
Abbildung 23: Die Navigation durch die Navigationsebenen [in Anlehnung: Prosser, Ossimitz (2000
a), S. 24 ]
- 72 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
5.10.8
KONZEPTIONELLE ODER SEMANTISCHE MODELLIERUNG
5.10.8.1 GRAPHISCHE MODELLIERUNG
Es gibt nicht viele Methoden ein Data Warehouse zu modellieren. Als eine der
wichtigsten wird hier das Dimensional Fact (DF) Modell von Golfarelli, Maio und Rizzi
genannt [vgl. Golfarelli et al. (1998)]. Dieses Modell besteht aus baumartigen „FactSchemas“, die aus Schlüsselfeldern, Dimensionen und Hierarchien bestehen.
Artikeltyp
Hierarchie
Größe
Artikel
Nicht-aggregierbare
Attribute
Adresse
ZEIT
Monat
Verkauf
Verkaufte Menge
Umsatz
Tag
Kunde
Gruppe
Schlüsselfelder
Abbildung 24: Einfaches Modell eines dreidimensionalen „Fact-Schema“ [in Anlehnung: Prosser,
Ossimitz, (2000 a), S. 29]
Die Modellierung mit dem „Fact-Schema“ beginnt mit der Auswahl der Facts
(Schlüsselfelder, Kennzahlen), die für die Betrachtung interessant erscheinen. Danach
wird für jedes Schlüsselfeld ein Attributbaum entwickelt (siehe Abbildung 25).
- 73 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 25: Attributsbaum vor Pruning und Grafting
[in Anlehnung: Prosser, Ossimitz, (2000 a), S. 33]
Dieser wird durch „Pruning“ und „Grafting“ vereinfacht. Der Zweck des „Pruning“ und
„Grafting“ ist eine Vereinfachung des Modells. Beim „Pruning“ wird dabei ein
kompletter Unterbaum vom Baum abgetrennt und aus der Betrachtung des „FactSchemas“ entfernt. Es ist natürlich dann auch unmöglich Daten dieses Unterbaumes zu
aggregieren. Beim „Grafting“ werden nur einzelne Attribute, die uninteressante
Information enthalten entfernt. In Abbildung 26 sehen sie wie durch „Grafting“ das
Attribut „Rechnr“ entfernt wurde. Abschließend werden die Dimensionen, Hierarchien
und „Fact-Attribute“ festgelegt.
Abbildung 26: Attributsbaum nach Pruning und Grafting
[in Anlehnung: Prosser, Ossimitz, (2000 a), S. 34]
- 74 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
5.10.8.2 HALBGRAPHISCHE MODELLIERUNG
5.10.8.2.1
GITTER
Um eine systematische Planung der Datenwürfel durchführen zu können, benötigt man
zuerst die Menge der möglichen Datenwürfel. Diese kann durch ein Gitter dargestellt
werden. In Abbildung 27 sieht man ein Beispiel für ein Gitter mit 3 Dimensionen
(Kunden, Artikel, Zeit). Die Dimensionen unterteilen sich in folgende Hierarchiestufen:
•
Kunden: Kunde individuell (K_id), Kundengruppe (K_gr), Kunden gesamt
(K_*)
•
Artikel: Artikel individuell (A_id), Artikelgruppe (A_gr), Artikel gesamt (A_*)
•
Zeit: Tag (Z_t), Monat (Z_m), Jahr (Z_j), Zeit gesamt (Z_*)
Abbildung 27: Gitter [in Anlehnung: Prosser, Ossimitz (2000 a), S. 40]
Die Darstellung der Würfel in einem Gitter bringt viele Vorteile. Diese sind:
•
Jede Kombination der Hierarchiestufen der Dimensionen kann separat
dargestellt werden
•
Man kann relativ leicht erkennen, welcher Würfel aus welchen Würfeln
abgeleitet werden kann
•
Das Gitter zeigt alle Kombinationsmöglichkeiten
•
Das Gitter zeigt alle Kombinationsmöglichkeiten redundanzfrei.
Der große Nachteil des Gitters ist jedoch, dass es relativ rasch mit steigender Anzahl der
Dimensionen und Hierarchien zu komplex und unübersichtlich wird. [vgl.
Prosser/Ossimitz (2001) S.55]
- 75 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Allgemein ergibt sich die Größe eines Gitterverbandes aus
Anzahl(Knoten)= ∏
n
kn
kn.....Anzahl der Hierarchiestufen in Dimension n
Für weiterführende Literatur zum Gitter siehe Crawley/Dilworth (1973).
5.10.8.2.2
AGGREGATION PATH ARRAY
Da das Gitter nicht für die Darstellung sehr komplexer mehrdimensionaler Strukturen
geeignet ist, liegt es auf der Hand, eine Methode zu nutzen, welche die Vorteile des
Gitters mit einer einfachen übersichtlichen Darstellung von anderen
Modellierungsmethoden kombiniert. Das Ergebnis ist die von Prosser und Ossimitz
entwickelte Methode des APA (Aggregation Path Array). Dieser Methode wurde unten
der Abschnitt 6 gewidmet und wird dort entsprechend erläutert. Deshalb soll sie hier nur
der systematischen Einordnung willen angeführt werden.
5.10.9
LOGISCHE UND PHYSIKALISCHE MODELLIERUNG
5.10.9.1 STAR-SCHEMA
Das Star-Schema ist eine der bekanntesten Modellierungstechniken für ein Data
Warehouse. Es besteht aus zwei Arten von Tabellen, dem „Fact-Table“ und dem
Dimension-Table. Der Name Star-Schema rührt daher, dass die Dimension-Tables
sternförmig um das zentrale „Fact-Table“ (Basisfaktentabelle) angeordnet sind. (siehe
Abbildung 28). Die Anzahl der Tabellen entspricht immer der Summe von
Dimensionen und dem „Fact-Table“.
- 76 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 28: Star-Schema mit „Fact-Table“ (gelb) und vier Dimension-Tables
[In Anlehnung: Prosser, Ossimitz (2000 a), S. 51]
Zentraler Dreh- und Angelpunkt des Star-Schemas ist das „Fact-Table“. Es erfasst jede
Transaktion in einer eigenen Zeile, wodurch es zur größten Tabelle des Schemas wird.
Ein Dimensionselement jeder Dimension und mehrere numerische Kennzahlen
(measures) stellen die Spalten des „Fact-Table“ dar, wodurch eine Transaktion
eindeutig definiert wird. Anhand des Dimensionselements ist eine Verbindung zum
entsprechenden Dimension-Table gewährleistet, entsprechend einem Primärschlüssel.
Dort sind die verschiedenen Aggregationsstufen definiert, über die die Transaktionen
des „Fact-Table“ konsolidiert werden können. [vgl. Schnizer et al., (1997), S. 48 f]
Es gibt jedoch auch Nachteile des Star-Schemas. Es führt zu einem großen und teuren
Bedarf an Plattenspeicher, hervorgerufen durch die Mehrfachspeicherung von
Informationen. Große Dimension-Tables wirken sich sehr nachteilig auf die
Performance aus. Aus diesem Grund wurde auch das Snowflake-Schema entwickelt.
- 77 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 29: Das klassische Star-Schema [In Anlehnung: Prosser/Ossimitz (2000a ) S. 51]
5.10.9.2 FACT CONSTELLATION-SCHEMA
Beim klassischen Star-Schema kommt es bei großen Datenmengen zu
Performanceproblemen. Besonders der große Base Fact Table bereitet Schwierigkeiten,
da auch alle Aggregate im Base Fact Table gespeichert werden. Deshalb wurde das Fact
Constellation-Schema entwickelt, welches eine Abänderung des Star-Schemas darstellt.
Dabei werden die aggregierten Daten und die nicht aggregierten Daten separat
gespeichert. Deshalb unterscheidet man Aggregated Fact Tables (AFT) für die
Aggregate und den Basic Fact Table für die atomaren Daten.
Als Vorteile des Fact Constellation Schemas ist folgendes zu nennen:
•
Das Level Attribut wird nicht mehr benötigt.
•
Die Performance ist bedingt durch die separate Speicherung der Aggregate
verbessert.
Als Nachteile des Fact Constellation-Schemas ist zu nennen:
•
Mit der Anzahl der Dimensionen steigt auch die Anzahl der AFT rapide an.
Dadurch wird das Model sehr komplex und schwerer aufzubauen und zu warten.
- 78 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
•
Die Abfragen über mehrere Aggregate und/oder atomare Daten erfordert
komplexere Joins.
Im Fact Constellation-Schema sind die Dimensionstabellen nach wie vor
denormalisiert. Dies kann bei großen Dimensionstabellen, welche viele Hierarchien
enthalten, auch zu Performanceproblemen führen.
[vgl. Prosser/Ossimitz (2001) S. 73ff]
Abbildung 30: Das Fact Constellation-Schema [Quelle: Prosser/Ossimitz (2001) S. 76]
5.10.9.3 SNOWFLAKE-SCHEMA
Beim Snowflake-Schema, das eine Erweiterung des Star-Schemas darstellt, wird
zusätzlich zur Normalisierung des „Fact-Tables“, eine Normalisierung der DimensionTables vorgenommen. Die Dimensionsattribute werden nicht mehr wie beim Star
Schema in einer einzigen Tabelle pro Dimension gehalten, sondern es gibt für jedes
Dimensionsattribut eine eigene Tabelle. In den Dimension-Tables stehen nur noch die
Attributsschlüssel (z.B. MonatID), die auf die dazugehörigen Attribut-Tables
verweisen.
- 79 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 31: Snowflake-Schema mit Attribut-Tables
[in Anlehnung: Prosser, Ossimitz (2000a), S. 62]
Die Vorteile des Snowflake-Schemas liegen in der reduzierten Anzahl der zu
bearbeitenden Zeilen – mit der entsprechenden Auswirkung auf die Performance – und
in der Einsparung der Plattenkapazität. Nachteile liegen in der komplexeren
Datenstruktur. [vgl. Schnizer et al. (1997) S. 50 f]
5.10.9.4 GALAXY-SCHEMA
Beziehen sich mehrere unterschiedliche Fakten auf die gleiche Dimensionen, wobei
zwei Dimensionen genau dann gleich sind, wenn ihre komplexen und Basisobjekttypen
gleich sind, dann wird eine Dimension mit den entsprechenden Fakten verbunden, da
Dimensionen nicht redundant implementiert werden. Das durch derartige Verbindungen
entstandene Schema wird Galaxy-Schema genannt. Ein Galaxy-Schema repräsentiert
aus Sicht der OLAP-Anwendung eine Multicube-Architektur. Eine MulticubeArchitektur ist dadurch gekennzeichnet, dass verschiedene Hypercubes gemeinsame
Dimensionen haben. Die Abbildung 32 zeigt die Zusammenhänge zwischen GalaxySchema und Mulitcube-Architektur.[vgl. Rautenstrauch/Schulze (2003) S. 332]
- 80 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 32: Galaxy-Schema und Multitube-Architektur
[Quelle: Rautenstrauch/Schulze (2003) S. 334]
5.10.9.5 DAS UNIMU-SCHEMA
Das Unimu- Schema (Uniformes Datenschema für multidimensionale Daten) wurde an
der Universität Leipzig entwickelt. Dabei wurde dieses Schema beim praktischen
Einsatz in einem Energieunternehmen entwickelt. Dabei wurde in folgenden Schritten
vorgegangen:
•
Uniformierung der Datenstruktur für die analyseorientierte Zusammenfassung
dimensionsbezogener, betriebswirtschaftlicher Kennzahlen in einer Tabelle.
•
Zerlegung der Datenstruktur in eine Fakttabelle sowie je eine Tabelle für die
(uniforme) Zeitdimension und die (uniforme) Objektdimension unter Nutzung
des Star-Schemas.
•
Bildung einer Dimensionstabelle für Kennzahlen basierend auf dem SnowflakeSchema.
•
Hierarchische Verknüpfung von Dimensionspositionen durch die Ergänzung von
Hierarchietabellen.
Das Unimu-Schema basiert auf einer dreidimensionalen Modellierung
betriebswirtschaftlicher Kenngrößen:
•
Zeitdimension: Jeder Fakt ist mit einer uniform verwendbaren Zeit_id versehen.
Beliebige zeitbezogene Aggregate können somit in einer Fakttabelle abgelegt
- 81 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
werden. Die zeitliche Dimensionierung kann individuell für alle Kombinationen
von Kennzahl- und Objektdimensionen festgelegt werden.
•
Kennzahldimension: Die Kennzahlen werden in einer Dimension
zusammengefasst. Neue Kennzahlen können so ohne Datenmodelländerung und
Anpassung der Präsentationsanwendung hinzugefügt werden. Nicht sinnvolle
Kombinationen von Kennzahlen und Objekten (z.B. Preis pro Produktgruppe)
können ausgeschlossen werden. Die flexible Modellierung ist allerdings mit dem
Nachteil einer umfangreichen Fakttabelle verbunden.
Objektdimension: Durch die Modellierung erfolgt eine Trennung in logische und
semantische Dimensionen. Semantische Dimensionen sind z.B. Kunden, Produkte und
Regionen. Logische Dimensionen entsprechen oder ergeben sich aus der Verknüpfung
semantischer Dimensionen (z.B. Kunden pro Region).
Abbildung 33: Das Unimu-Schema [Quelle: Ehrenberg/Heine (1998) S. 507]
Der große Vorteil des Unimu-Schemas ist, dass Dimensionen als Daten und nicht als
Datenstrukturen verwaltet werden. Dadurch können neue Kennzahlen, neue
Objektdimensionen und neue zeitliche Granularitäten ohne Schemaänderungen
abgebildet werden.[vgl. Ehrenberg/Heine (1998) S. 503ff]
- 82 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
6 DIE MODELLIERUNGSMETHODE AGGREGATION PATH
ARRAY
Die von Prosser und Ossimitz entwickelte Methode des APA (Aggregation Path Array)
versucht die Modellierungsmethode des Gitters entsprechend zu verbessern. Dabei
versucht man im Gitter nicht die gesamten Kombinationen der Dimensionen in ihren
Hierarchiestufen darzustellen, sondern man gibt für jede Zelle im Gitter nur die
geänderte Hierarchiestufe der Dimension (Attributsnamendarstellung) bzw. die
Dimension, die sich geändert hat, an (Kurznotation). Deshalb ergibt jede Zeile alle
möglichen Aggregationsschritte aller Dimensionen wieder. Es wird von Zeile zu Zeile
nur die Reihenfolge der Aggregationsschritte verändert. Das führt jedoch zu
Redundanzen zwischen den einzelnen Zeilen. Diese werden dann in einem zweiten
Schritt entfernt bzw. ausgemerzt oder, wie in dem unten beschriebenen Algorithmus, in
einem Schritt vollzogen. [vgl. Prosser/Ossimitz (2000b), S. 10 ff]
In Abbildung 34 sieht man das analoge Beispiel des Gitters (siehe Abbildung 27) für ein
APA mit 3 Dimensionen (Kunden, Artikel, Zeit).
1
1
1
1
1
1
2
2
3
1
1
1
2
2
3
2
3
3
2
2
3
2
3
3
3
3
3
2
3
3
3
3
3
3
3
2
3
3
3
3
3
2
3
2
2
3
3
2
3
2
2
1
1
1
3
2
2
1
1
1
1
1
1
K_gr
K_gr
K_gr
K_gr
K_gr
K_gr
A_gr
A_gr
Z_m
K_*
K_*
K_*
A_gr
A_gr
Z_m
A_*
Z_m
Z_y
A_gr
A_gr
Z_m
A_*
Z_m
Z_y
Z_m
Z_y
Z_*
A_*
Z_m
Z_y
Z_m
Z_y
Z_*
Z_y
Z_*
A_gr
Z_m
Z_y
Z_*
Z_y
Z_*
A_gr
Z_*
A_*
A_*
Z_y
Z_*
A_gr
Z_*
A_*
A_*
K_gr
K_gr
K_gr
Z_*
A_*
A_*
K_*
K_*
K_*
K_*
K_*
K_*
Abbildung 34: Darstellung des APA des Praxisbeispiels in Kurznotation (links) und mit
Attributsnamen (rechts) nicht redundanzfrei [in Anlehnung: Prosser, Ossimitz, (2000 a), S. 43]
Die Dimensionen unterteilen sich in folgende Hierarchiestufen:
•
Kunden: Kunde individuell (K_id), Kundengruppe (K_gr), Kunden gesamt
(K_*)
•
Artikel: Artikel individuell (A_id), Artikelgruppe (A_gr), Artikel gesamt (A_*)
•
Zeit: Tag (Z_t), Monat (Z_m), Jahr (Z_j), Zeit gesamt (Z_*)
Dabei gibt jede Zelle, wie oben erwähnt, die Änderung einer Hierarchiestufe an.
Allgemein beginnt jede Zeile mit den Dimensionen in der Ausgangshierarchiestufe 0
- 83 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
( d10 , d 20 , d 30 oder K_id, A_id, Z_d). In werterer Folge wird in jeder Spalte der Zeile für
eine weitere Dimension die Hierarchiestufe um eins erhöht bis in der letzten Spalte
jeder Zeile die Endsituation mit allen Dimensionen in der höchsten Hierarchiestufe steht
(z.B. d 12 , d 22 , d 33 oder K_*, A_*, Z_*). So ergibt die markierte Zelle in Abbildung 34
die Kombination d11 , d 22 , d 31 oder K_gr, A_*, Z_d. Jede Zelle im Gitter enthält aus
Übersichtlichkeitsgründen nur die Hierarchiestufe, die im Vergleich zum Vorgänger
links in derselben Zeile hochgezählt wurde. Damit kann man aber für jede Zelle relativ
leicht den Würfel generieren, der dargestellt wird. Das geschieht indem man die höchste
bis dahin in der Zeile links von der Zelle angeführte Hierarchiestufe der bereits
zumindest einmal aggregierten Dimensionen nimmt und für die anderen Dimensionen
die niedrigste Hierarchiestufe einsetzt. Für unseren markierten Würfel wäre somit die
konkrete Ausprägung d11 , d 22 , d 30 oder K_gr, A_*, Z_d.
Für die formale Definition des Permutationsalgorithmus [vgl. Prosser/Ossimitz (2000b), S
12ff ], der zum Array in Abbildung 34 führt, benötigen wir zunächst die Definition eines
Verschiebeoperators der folgenden Form: Gegeben sei ein Array von Zeilenvektoren,
von denen alle dieselben Elemente dn, allerdings in einer anderen Reihenfolge
beinhalten; ein Element dn kommt in einem Zeilenvektor nur einmal vor. Das Array
bestehe zunächst nur aus einer Zeile: z1=(d1, d2, d3, ...., dn-1, dn). Wir bilden nun eine
zweite Zeile und definieren dafür den Verschiebeoperator V der Form
V (d a → d b z − r ) mit r ∈ N+, sodass die aktuelle Zeile z aus Zeile (z-r) abgebildet
wird, indem alle Elemente im Vektor vor da hinter db verschoben werden, die Elemente
dazwischen um eine Position nach links aufrücken und alle Elemente, die ursprünglich
nach db lagen, wieder unverändert bleiben. Damit erzeugt die Operation
V (d 2 → d n −1 z − 1) in Zeile z =2 den Vektor z2 = (d1, d3, ...., dn-1, d2, dn). Mit Hilfe diese
Verschiebeoperators kann nun folgendes Array gebildet werden:
z =1
( d11 ,..., d 1i (1) ,..., d n1− 2 ,..., d ni (−n2− 2) , d n1−1 ,..., d ni (−n1−1) , d n1 ,..., d ni ( n ) )
markiere Elemente d11 ,..., d ni ( n )
/* Der Zähler für die Hierarchiestufen in Dimension n sei als k[n] bezeichnet, */
/* wobei i(n)-k[n] die aktuell bearbeitete Hierarchiestufe in n bezeichnet; */
k[1]=0
do unitl i(1)-k[1]<0
k[2]=0
- 84 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
do until i(2)-k[2]<0
…
k[n-2]=0
do until i(n-2)-k[n-2]<0
/* Solange i(n-2)-k[n-2]>0 ist, also eine Hierarchiestufe d n1− 2 oder höher angesprochen
*/ /* wird, wird der Verschiebeoperator angewandt; wenn i(n-2)-k[n-2]=0, dann wird
nur */ /*noch die innere Schleife durchgeführt; ein Verschieben gibt es nicht mehr, da
d n1 */ /*nicht im Array ist. Die analoge Überlegung gilt für alle Dimensionen m < (n1).*/
/* Zunächst werden ausschließlich Dimensionen n und n-1 permutiert. */
perform _ procedure(inner _ loop)
if i(n − 2) − k[n − 2] > 0
z ← z +1
V (d ni (−n2−2)−k [ n −2] → d ni ( n ) z − (i (n − 1) + 1))
markierte Elemente d n1−1 ,K, d ini ( n )
end if
k[n − 2] ← k[n − 2] + 1
end do
K
if i (2) − k (2) > 0
z ← z +1
(
V (d ni (−n2− 2 ) − k [ n − 2 ] → d ni ( n ) z − (i (n − 1) + 1)
)
markiere Elemente d 31 ,K , d ni ( n )
end if
k [ 2] ← k [ 2] + 1
end do
if i (1) − k[1] > 0
z ← z +1
r = n −1
⎞
⎛
V ⎜⎜ d 1i (1) − k [1] ← d ni ( n ) z − ∏ (i (r ) + 1) ⎟⎟
r =2
⎠
⎝
1
i(n)
markierte Elemente d 2 , K , d n
end if
k[1] ← k[1] + 1
end do
- 85 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
/* Die markierten v sind die redundanzfreie Menge v ∈ RF.*/
procedure (inner_loop)
/* Diese Schleife realisiert die Permutation der Dimensionen n und (n-1) */
k[n − 1] = 0
do until k[n − 1] = i[n − 1]
z ← z +1
(
)
V d ni (−n1−1) − k [ n −1] → d ni ( n ) z − 1
1
n
markierte Elemente d , K , d ni ( n )
k[n − 1] ← k[n − 1] + 1
end do
end _ procedure
Der Verband in Abbildung 34 stellt aber die nicht redundanzfreie Kombination aller
Dimensionen und Hierarchiestufen dar. Abbildung 35 stellt die redundanzfreie Menge
des Praxisbeispiels durch farbliche Markierung dar.
1
1
1
1
1
1
2
2
3
1
1
1
2
2
3
2
3
3
2
2
3
2
3
3
3
3
3
2
3
3
3
3
3
3
3
2
3
3
3
3
3
2
3
2
2
3
3
2
3
2
2
1
1
1
3
2
2
1
1
1
1
1
1
K_gr
K_gr
K_gr
K_gr
K_gr
K_gr
A_gr
A_gr
Z_m
K_*
K_*
K_*
A_gr
A_gr
Z_m
A_*
Z_m
Z_y
A_gr
A_gr
Z_m
A_*
Z_m
Z_y
Z_m
Z_y
Z_*
A_*
Z_m
Z_y
Z_m
Z_y
Z_*
Z_y
Z_*
A_gr
Z_m
Z_y
Z_*
Z_y
Z_*
A_gr
Z_*
A_*
A_*
Z_y
Z_*
A_gr
Z_*
A_*
A_*
K_gr
K_gr
K_gr
Z_*
A_*
A_*
K_*
K_*
K_*
K_*
K_*
K_*
Abbildung 35: Darstellung des APA des Praxisbeispiels in Kurznotation (links) und mit
Attributsnamen (rechts) redundanzfreie Menge farblich markiert
[in Anlehnung: Prosser, Ossimitz (2000 a), S. 43]
Die redundanzfreie Menge aus einem fertig generierten Array, wie in Abbildung 35,
erhält man, wenn man folgenden Algorithmus vollzieht:
(1) Der Pfad in Zeile 1 des Array stellt alle Element das erste Mal dar und gehört somit
gesamt zur redundanzfreien Menge.
(2) Danach durchläuft man die nächste Zeile von links nach rechts und vergleicht jede
Zelle mit der Zelle in der unmittelbar übergeordneten Zeile. Dieser Ablauf wird bis zum
ersten Auftreten einer Ungleichheit der beiden Zellen durchgeführt, wobei all diese
Zellen unmarkiert bleiben. Mit dem Auftreten der ersten Ungleichheit werden alle
- 86 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
folgenden Zellen bis zum Auftreten der obersten Hierarchiestufe der letzten Dimension
(in diesem Fall das Element Z_* oder d 33 ) markiert. Alle Zellen rechts von dieser Zelle
bleiben unmarkiert.
(3) Punkt 2 wird für alle Zeilen bis zur letzten Zeile durchlaufen.
Als Ergebnis sieht man die in Abbildung 35 dargestellte farblich markierte
redundanzfreie Menge an Würfeln. Diese Menge gibt somit die vollständige und
redundanzfreie Menge (i. e. sie enthält alle aus dem Basiswürfel ableitbaren Vektoren).
Für einen Beweis siehe Prosser/Ossimitz (2000b) Anhang.
Eine weitere im Data Warehouse Management entscheidende Frage ist, welche Würfel
interessant für den Anwender und welche davon zu materialisieren sind. Hier ergibt sich
ein Zielkonflikt zwischen der Performance (möglichst viele Würfel zu materialisieren,
um schnelle Abfragen zu haben) und den Kosten für unnötige Datenhaltung und
Prozessorarbeitsstunden. Das Finden einer optimalen Lösung, die ja von Anwender zu
Anwender völlig verschieden sein kann, unterstützt das APA in relativ übersichtlicher
Art und Weise. So könnte eine anwenderspezifische Anforderung für die interessanten
Würfel lauten: „ Ich benötige einen Monatsbericht für alle Artikelgruppen mit einem
kompletten Drill Down aller Artikel unabhängig von Kunden (a). Zusätzlich will ich für
jeden individuellen Kunden einen Jahresbericht für alle Artikel haben (b).“
Abbildung 36: Darstellung der interessanten Würfel
[in Anlehnung: Prosser, Ossimitz (2000 b), S. 17 ]
Abbildung 36 stellt die Würfel, welche die Anforderungen erfüllen, getrennt nach
Bereich a und Bereich b markiert, dar. Dies sind die Würfel, die für die Abfrage
benötigt werden.
- 87 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Zusätzlich stellt sich nun die Frage, welche Würfel nun tatsächlich physisch
materialisiert werden sollen, da es aus Speicherplatzgründen in den seltensten Fällen
möglich ist, alle interessanten Würfel zu materialisieren. Deshalb kann diese Frage
nur beantwortet werden, wenn man die Derivate der einzelnen Würfel betrachtet.
Das APA kann dabei zur Bestimmung der Derivate eines Vektors verwendet
werden:
/* Bestimme die Anzahl der Spalten des Arrays */
s max = ∑ i (n)
n
/*Bestimme die Anzahl der Zeilen des Arrays */
z max =
r = n −1
∏ (i(r ) − 1)
r =1
/* Abarbeiten aller Zeilen bis zum Ende des Arrays in zmax erreicht ist */
z =1
do until z > z max
s = s max , ende = 0
do until s = 0 or ende = 1
(
if array _ element ( z , s ) = d mj ( m ) ∈v
)
markiere Zelle s in z
ende = 1
else s ← s − 1
end if
end do
z ← z +1
end do
Alle Zellen (=Vektoren) w, die markiert oder rechts der markierten Zelle ihrer Zeile im
Array liegen sind Derivate von v, w ∈ A(v). A(v) ∩ RF wäre die redundanzfreie Menge
an Derivaten. [vgl. Prosser/Ossimitz (2000b) S. 18f ]
Zum Algorithmus: Zunächst werden Zeilen- und Spaltenanzahl in zmax bzw. smax
hinterlegt. Da nur auf Elemente im APA abgefragt wird, wird die unterste
Hierarchieebene ignoriert. Dies ist aber sinnvoll, da sich aus der untersten immer alle
anderen Hierarchiestufen der Dimensionen ableiten lassen – für die Herleitung der
Derivatsmengen sind daher nur die Dimensionen mit einer Hierarchiestufe größer oder
gleich 1 im Vektor entscheidend. Markiert wird von rechts kommend (Beginn bei smax)
- 88 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
in jeder Zeile jene Zelle, in der das erste Mal ein Element aus v einer Stufe ≥ 1
vorkommt. [vgl. Prosser/Ossimitz (2000b) S. 18]
Wir gehen von dem in Abbildung 36 angeführten Beispiel aus und versuchen nun die
Menge der zu materialisierenden Würfel abzuleiten. Dabei betrachten wir zuerst die
Derivativmenge Bereich x des Würfels x (blau markiert). Wir sehen, dass zwar der
Bereich a vollständig mit den Derivativen des Würfels x abgedeckt ist. Der Bereich b
jedoch nicht aus dem Würfel x abgeleitet werden kann.
Abbildung 37: Anzeigebeispiel der Derivative (Bereich x) des Würfels x
[in Anlehnung: Prosser, Ossimitz (2000 b), S. 17]
Abbildung 38: Anzeigebeispiel der Derivate (Bereich y) des Würfels y
[in Anlehnung: Prosser, Ossimitz (2000 b), S. 17]
- 89 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Genauso betrachten wir die Derivatsmenge (Bereich y) des Würfels y (blau
markiert) in Abbildung 38. Dabei ist zu erkennen das der Würfel y zwar den Bereich
b abdeckt, den Bereich a jedoch nicht tangiert. Damit ist es notwendig zumindest
zwei Würfel zu materialisieren.
Deshalb versuchen wir ein Materialisieren beider Würfel in Abbildung 39
darzustellen. Die Gesamtderivatsmenge von Bereich x und Bereich y wird rechts
von der dicken Linie dargestellt.
Abbildung 39: Anzeigebeispiel der Derivate (Bereich x + y) der Würfels x und y
[in Anlehnung: Prosser, Ossimitz (2000 b), S. 17]
Im Moment gibt es für die Bestimmung der zu materialisierenden Würfel aus den
interessanten Würfel keinen wissenschaftlich ausgereiften Algorithmus. Deshalb
können die zu materialisierenden Würfel im Moment nur durch Austesten bestimmt
werden. Dies soll sich durch die in Abschnitt 7 beschrieben Heuristik ändern.
7 FORSCHUNGSSCHWERPUNKT UND ERGEBNISSE
7.1 DAS GRUNDPROBLEM UND DER LÖSUNGSANSATZ
Der zentrale Fokus beim Aufbau von Data Warehouse-Konzepten sollte auf den Nutzen
für den Anwender gelegt werden. Aus diesem Grund ist neben dem leichten, intuitiven
Zugang unbedingt besonderes Augenmerk auf hohe Flexibilität und Schnelligkeit bei
der Bearbeitung von Endbenutzerabfragen zu legen. Durch die Bestimmung der
richtigen zu materialisierenden Würfel, sollen diese Anforderungen befriedigt werden.
- 90 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Das Grundproblem der Bestimmung der zu materialisierenden Würfel (materialized
cubes) unter Betrachtung der Menge der interessanten Würfeln (required cubes), welche
die benötigte Information enthalten, ist also ein Optimierungsproblem. Im einfachsten
Fall, in welchem keine Restriktionen hinsichtlich Ladezeit zum Aufbau des Data
Warehouse oder Speicherplatz bestehen, würden grundsätzlich die interessanten Würfel
und die zu materialisierenden Würfel identisch sein. Das heißt alle benötigten Würfel
würden auch physisch materialisiert. Damit wäre auch für den Benutzer die minimale
Zugriffszeit auf die Information garantiert. Es kann sogar sinnvoll sein noch zusätzliche
Würfel zu materialisieren, da sie die Materialisierungszeit nachfolgender Würfel
minimieren.
In der Praxis ist jedoch festzustellen, dass sowohl hinsichtlich des Speicherplatzes wobei dieses Problem von Tag zu Tag an Bedeutung verliert, da die Kosten für Speicher
im Zeitablauf rapide sinken - aber im besonderen hinsichtlich der Ladezeit der Daten,
welche für das Data Warehouse veranschlagt werden muss, Begrenzungen gelten.
Durch die immer stärker werdende multinationale Unternehmensführung wird es immer
schwieriger die Zeit für die Generierung und die Updates der Daten in einem Data
Warehouse zu planen. Das eigentliche Problem ergibt sich daraus, dass während des
Updates oder Neuaufbaus des Data Warehouses der Zugriff auf dieses nicht möglich ist.
Wurden bei nationalen Unternehmen diese Updates einfach während der Nacht erledigt,
kann dies beispielsweise von einer weltweit operierenden Fluglinie, welche die Daten
immer an einem bestimmten Punkt der Welt gerade benötigt, nur sehr schwer erledigt
werden. So bleiben für diese Unternehmen oft nur Zeitbereiche von wenigen Stunden
pro Woche oder Tag, um ihre Daten auf den neusten Stand zu bringen.
Aus diesem Grund besteht ein Optimierungsproblem, welches sich aus Konflikt der
schnellstmöglichen Abfragezeit und der schnellstmöglichen Aktualisierungs- bzw.
Aufbauzeit ergibt. Für diese Problem einen Lösungsansatz zu finden stellt den Kern
meiner Forschungsarbeit dar.
7.2 DIE VORGEHENSWEISE
Um das Problem angreifbar, modellierbar und damit erforschbar zu machen gehe ich
von einigen Annahmen aus. Diese sind:
•
Bei verteilten Datenbanken, welche sich auf unterschiedlichen Servern weltweit
befinden, kann die Zeit für das Abfragen und Speichern eines Cubes von Würfel
zu Würfel total unterschiedlich sein. Diese Information steht dem Benutzer und
auch dem Planer eines Data Warehouses oft gar nicht zur Verfügung. Deshalb
gehe ich von einer durchschnittlichen Zugriffszeit pro Transaktion aus. Diese ist
durch den Benutzer für jedes Data Warehouse individuell festzustellen (z. B.
- 91 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
durch zufällige Abfrageprobeläufe) und als Berechnungsbasis in das von mir
entwickelte Gleichungssystem, bzw. die Software einzugeben. Diese
durchschnittliche Zugriffszeit kann sich natürlich im Zeitablauf ändern und
somit auch zu Veränderungen im Aufbau des Data Warehouse Systems führen.
•
Es besteht ein linearer Zusammenhang zwischen den in den Cubes gespeicherten
Daten. Wird zum Beispiel in einem Cube der Jahresumsatz in einer FLOAT
Variablen mit 8 Byte gespeichert, ist der benötigte Speicherplatz in einem
anderen Cube, in welchem der Monatsumsatz gespeichert wird zwölf mal so
groß. Das mag in der Praxis nicht immer stimmen, da moderne
Datenbankmanagementsysteme mit ihren Query Optimizern zumeist
automatische Indizes erzeugen. Geht man aber von einem einfachen Modell aus
sehr wohl. Diese Vereinfachung des Models ist jedoch zwingend notwendig um
die Komplexität des Problems zu bereinigen und eine wissenschaftliche
Untersuchung zu ermöglichen.
•
Es besteht ein linearer Zusammenhang zwischen der Anzahl der Tupel im Table
der abzufragenden Datenbank und der Abfragezeit. Empirische Untersuchungen
von Dunemann (2002) belegen diese Annahme, da eine sehr starke Korrelation
zwischen diesen beiden Werten besteht.
•
Es besteht ein linearer Zusammenhang zwischen der Anzahl der Tupel in der
Ergebnismenge einer GROUP BY Abfrage und der Abfragezeit der Query.
Diese Annahme wird ebenfalls von Dunemann (2002) untermauert, welcher eine
Korrelation festgestellt hat. Diese ist allerdings nicht so stark wie bei der
Korrelation zwischen Anzahl der Tupel in der abzufragenden Datenbank und
Abfragezeit. Eine genaue Beschreibung dieser Studie wird in Kapitel 7.5
behandelt.
7.3 ABGRENZUNG DER PHASEN DER BETRACHTUNG
Beim Aufbau und beim Update eines Datawarehouse unterscheiden wir 3 verschiedene
Phasen:
•
Phase des Aufbaus des BFT aus den operativen und externen Datenquellen
•
Aufbau der materialisierten Sichten aus dem BFT
•
Abfragen der Informationen aus dem BFT oder den materialisierten Sichten
- 92 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 40: Abgrenzung der Phasen der Betrachtung
In meinen Überlegungen gehe ich von einer abgeschlossenen ersten Phase aus. Das
heißt der Aufbau des BFT aus operativen und externen Systemen muss in jedem Fall
erfolgen und hat auf die Auswahl der zu materialisierenden Sichten keinen Einfluss.
Deshalb wird diese Phase und die Zeit, welche für diese Phase benötigt wird, nicht in
die Betrachtungen aufgenommen. In der zweiten Phase, in der die materialisierten
Sichten erzeugt werden, besteht eine strikte Zeitbeschränkung, da bis zur neuen
Aggregation die Würfel nicht zur Verfügung stehen, bzw. unrichtige Information
enthalten. Die dritte Phase umfasst die Abfragen der Benutzer bis zum neuerlichen
Aufbau des Warehouse. Dabei werden die Gesamtkosten der Abfragen in dieser Periode
durch das Produkt der Abfragekosten mit den geschätzten Anzahl der Abfragen
errechnet. Dadurch werden auch wichtige Cubes früher materialisiert, da Kosten
eingespart werden können.
- 93 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.4 VERWANDTE ALGORITHMEN IM
PROBLEMZUSAMMENHANG
In diesem Abschnitt versuche ich bestehende Algorithmen zu präsentieren, welche
einen Beitrag zur Lösung der Problemstellung liefern können. Dabei versuche ich
bestehende, in der Literatur erwähnte, Algorithmen möglichst detailliert zu beschreiben.
Unsere Aufgabe besteht unter anderem darin eine gute Heuristik zur Bestimmung der zu
materialisierenden Würfel zu finden. Um die Qualität dieser Heuristik zu bewerten
bedarf es jedenfalls der Bestimmung der optimalen Lösung. Dies soll durch diese
Algorithmen programmtechnisch umgesetzt und überprüft werden. Zusätzlich werden
Auszüge dieser Algorithmen in den Heuristiken der Software verwendet.
7.4.1 KÜRZESTE UND LÄNGSTE WEGE
Im Problemkreis der kürzesten und längsten Wege versucht man ein reales System oder
ein zu lösendes Problem durch Graphen darzustellen. Standardaufgaben der
Graphentheorie in diesem Kontext sind die als „Single source path“-Problem bekannte
Bestimmung aller kürzesten Wege von einem Knoten zu allen anderen und die
Bestimmung kürzester Wege zwischen allen Knoten, auch als „All pairs shortest path“Problem („Finde die mit den geringsten Kosten verbundene Möglichkeit, alle Punkte zu
verbinden.“) bekannt. In der Praxis, sowie auch in dem von uns behandelten
Problemkontext, werden als Weg die Kosten angesetzt und die Problemstellung von
einem kürzesten Weg Problem in ein minimales Kostenproblem gewandelt.
[vgl. Sedgewick (2002) S. 513f ]
Durch den hierarchischen Aufbau der Dimensionen und Hierarchien können die
materialisierten Würfel als Graphen ansehen werden (siehe auch Kapitel 5.10.8.2.1).
Diese werden durch Kanten verbunden, welche die Materialisierungskosten von einem
Aggregat einer niederen Hierarchiestufe auf ein Aggregat einer höheren Hierarchiestufe
symbolisieren.
7.4.1.1
7.4.1.1.1
BEGRIFFSBESTIMMUNGEN
GRAPHEN
Abstrakt fasst ein Graph D zwei Mengen zusammen: die Menge V der Knoten und die
Menge E der Kanten. Wir schreiben D= (V,E). Eine Kante ist ein geordnetes Paar von
Konten. In der Schreibweise (v,w) bezeichnet v den Anfangskonten und w den
Endknoten der Kante. In der Veranschaulichung
- 94 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 41: Graph mit zwei Knoten
zeigt die Spitze des verbindenden Pfeils auf den Endknoten w. v hat die Bedeutung des
Vorgängers (Parents) von w und w die des Nachfolgers (Derivative) von v. v und w
werden als adjazent oder benachbart bezeichnet und die Kante (v,w) heißt inzident zu
den beiden Knoten v und w. Kanten, die den Knoten v als Anfangsknoten haben, werden
auch als Ausgangsknoten von v und solche, die den Knoten v als Endknoten haben, als
Eingangskanten dieses Knotens bezeichnet. Ein Graph mit n Knoten hat im Maximum
n2 und im Minimum 0 Kanten. [vgl. Reß/Viebeck (2000) S. 364f]
7.4.1.1.2
EINGANGS- UND AUSGANGSGRAD
Als Grad eines Knotens eines Graphen bezeichnet man die Summe der Kanten, die den
Knoten als Ausgangsknoten (ausgehende Kanten) oder als Endknoten (eingehende
Kanten) haben. Die Anzahl der eingehenden Kanten heißt Eingangsgrad (indegree) und
die Anzahl der ausgehenden Kanten Ausgangsgrad (outdegree) des Knotens. [vgl.
Reß/Viebeck (2000) S. 365f]
7.4.1.1.3
WEG, ZYKLUS
Eine Folge von Knoten v1, v2, … vn heißt Weg (path) von v1 nach vn, wenn der Endpunkt
der Kante (vi-1, vi) mit dem Anfangspunkt der Kante (vi, vi+1) für 1<i<n zusammenfällt.
Die Länge des Weges ist gleich der Anzahl seiner Kanten. Kommt jeder Knoten längs
eines Weges nur einmal vor, sprechen wir von einem einfachen Weg. Ein einfacher
Weg, der geschlossen ist, bei dem also der erste und letzte Knoten zusammenfallen,
heißt (einfacher) Zyklus. Wir bezeichnen einen Graphen, der einen Zyklus hat, als
zyklisch und im anderen Fall als azyklisch. Ein einzelner Knoten lässt sich als Weg der
Länge Null interpretieren. Ein azyklischer Graph ist asymmetrisch und irreflexiv. Ein
Knoten w heißt von einem Knoten v aus erreichbar, wenn es einen Weg von v nach w
gibt. Die Bezeichnung „ist erreichbar“ ist transitiv und reflexiv. [vgl. Reß/Viebeck (2000) S.
366]
7.4.1.1.4
KNOTEN- UND KANTENWERTE
Anstelle von Nummern können Knoten auch durch Namen oder Schlüssel identifiziert
werden. Je nach Aufgabenstellung kann man den Knoten weitere Informationen
zuordnen. Auch Kanten können Werte (auch als Gewichte bezeichnet) haben, z.B.
Kosten wie Entfernungen oder Reisezeiten in einem Verkehrsnetz. Man spricht dann
von bewerteten oder gewichteten Graphen. Positive Gewichte werden auch als Kosten
- 95 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
bezeichnet. Die Knoten und Kantenwerte eines Graphen sind jeweils vom gleichen
Datentyp. [vgl. Reß/Viebeck (2000) S. 366f]
7.4.1.1.5
KLASSIFIZIERUNG VON GRAPHEN
Zur Klassifizierung von Graphen führen Reß/Viebeck (2000) folgende Begriffe ein [vgl.
Reß/Viebeck (2000) S. 363]:
Ein Graph heißt
•
symmetrisch, wenn mit der Kante (v,w) immer auch die Kante (w,v) für alle
Knoten v und w impiziert ist, d.h. in symmetrischen Graphen besteht eine
Verbindung zwischen zwei Knoten immer in beiden Richtungen. Ein Beispiel ist
ein Straßennetz, in dem Verkehr in beiden Richtungen möglich ist.
•
asymmetrisch, wenn die Existenz der Kante (v,w), v ≠ w , die Existenz der Kante
(w,v) ausschließt. In asymmetrischen Graphen besteht somit eine Verbindung
zwischen zwei verschiedenen Knoten immer nur in einer Richtung. Ein Beispiel
ist ein Straßennetz, das nur Einbahnverkehr zulässt.
•
reflexiv, wenn jeder Knoten des Graphen mit sich selbst verbunden ist, wenn
also (v,v) für alle v gilt.
•
irreflexiv, wenn die Existenz der Kante (v,v) für alle Knoten v ausgeschlossen
ist.
•
transitiv, wenn aus der Existenz der Kanten (v,w) und (w,z) die Existenz der
Kante (v,z) folgt. Eine typische transitive Relation ist v<w, z.B. in der Leseart „v
geht w voraus“.
7.4.1.2
KÜRZESTE WEGE VON EINEM KONTEN IM GRAPHEN ZU ALLEN
ANDEREN
Wir betrachten einen gewerteten Graphen, dessen Gewichte positiv sind, und befassen
uns mit der Aufgabe, für einen beliebigen Startknoten s die kürzesten Wege zu allen
anderen Knoten im Graphen zu bestimmen. Offensichtlich kann man den kürzesten
Abstand eines Knotens w vom Startknoten s einfach berechnen, wenn für jeden
Vorgängerknoten v von w der kürzeste Abstand von s bekannt ist. Der kürzeste Weg
von s nach w führt dann über den Vorgängerknoten v von w, für den die Summe der
Abstände von s nach v und von v nach w am kürzesten ist. Der Knoten s hat von sich
selbst den Abstand 0, der ein kürzester ist. Bezeichnen wir den Wert der Kante (v,w) mit
c(v,w) und die kürzeste Entfernung eines Knotens w von dem Startknoten s mit d(s,w),
so gelten die Rekursionsgleichungen:
- 96 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
•
d(s,s) = 0
•
d(s,w) = min {d(s,v)+c(v,w)} für v ∈ V (w) wobei V(w) die Menge der
Vorgängerknoten von w bedeutet.
Es stellt sich die Frage, wie man eine Reihenfolge der Knoten finden kann, damit
die Rekursion auch ausführbar wird. Eine Lösung dazu liefert der Algorithmus von
Dijkstra. Für azyklische Graphen findet man eine Reihenfolge einfach durch
topologisches Sortieren der Kanten. [vgl. Reß/Viebeck (2000) S. 403ff]
7.4.1.2.1
ALGORITHMUS VON DIJKSTRA
Dieser Algorithmus gilt für einen allgemeinen Graphen, er muss nicht azyklisch sein.
Bei diesem Ansatz ist jeder der Knoten eines Graphen entweder ein innerer Knoten,
Randknoten oder äußerer Knoten. Für die inneren Knoten ist bereits ihr kürzester
Abstand zum Startknoten s bekannt. Randknoten sind Knoten, für die man einen Weg
von s kennt, der aber noch nicht ein kürzester sein muss. Für äußere Knoten kennt man
noch keinen von s ausgehenden Weg. Zu Beginn ist der Startknoten s, der von sich
selbst den minimalen Abstand Null hat, der einzige innere Knoten und die direkten
Nachfolgerknoten bilden die Menge der Randknoten. Alle anderen Knoten sind äußere
Knoten. Die Menge der inneren Knoten wächst nun schrittweise von innen nach außen,
indem unter allen Randknoten derjenige mit dem kürzesten Abstand von s als nächster
innerer Knoten genommen wird. Seine Nachfolger werden, soweit sie bisher noch
äußere Knoten sind, zu neuen Randknoten. Für Randknoten, die erneut erreicht werden,
kann sich ein neuer, kürzerer Abstand von s ergeben, der dann den bisherigen kürzesten
Weg ersetzt.
Wir demonstrieren das Verfahren am Beispiel des folgenden Graphen und bestimmen
die kürzesten Wege des Knotens a zu allen anderen Knoten.
- 97 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 42: Bewerteter Graph [Quelle: Reß/Viebock (2000) S. 404]
Im ersten Schritt wird a zum inneren Knoten und seine Nachfolgerknoten b, c und d
werden zu Randknoten. Die verbleibenden Knoten e und f sind äußere Knoten. Unter
den Randknoten hat c den minimalen Abstand von a und c wird somit zum nächsten
inneren Knoten. Einen kürzeren Weg zu irgendeinem anderen Knoten kann es nicht
geben, da dieser notwendigerweise über die Knoten b oder d gehen müsste und d und b
von a aus keine kürzere Entfernung als c haben. Unter den bereits bekannten Wegen
von a nach b, c und d gibt es jetzt den kürzeren für d, der von a über c nach d führt. Wir
merken diesen kürzeren Weg nach d. Der Knoten f wird als Nachfolger vom Knoten c
zu einem Randknoten. Als nächsten inneren Knoten bestimmen wir den Knoten b, der
unter den Randknoten dieses Schrittes den minimalen Abstand von a hat. Die weiteren
Schritte sind aus der folgenden Tabelle ersichtlich.
- 98 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Innere Knoten
Knoten
Minimaler
Abstand von
s
1
a
0
2
a
c
0
2
3
a
c
b
a
c
b
d
a
c
b
d
f
a
c
b
d
f
e
0
2
4
0
2
4
5
0
2
4
5
6
0
2
4
5
6
7
Schrittfolge
4
5
6
b
c
d
b
d
f
d
f
Randknoten
vorläufig
minimaler
Abstand von
s
4
2
6
4
5
8
5
7
f
e
6
7
d
d
e
7
d
Knoten
Vorgänger
a
a
a
a
c
c
c
b
äußere
Knoten
e
f
e
e
Tabelle 7: Berechnung der kürzesten Wege von einem Knoten in einem Graph zu allen anderen
[Quelle: Reß/Viebeck (2000) S. 405]
In der folgenden Implementation des Algorithmus von Dijkstra für einen bewerteten
Graphen in Adjazenzlistendarstellung sehen wir die Arrays distance und parent, beide
von der Länge D.GetNumVertices, vor. parent ist von Typ VPostition und distance vom
Typ float. Für einen Knoten v mit der Ordnungsnummer i zeigt parent[i]!=NULL auf
den Vorgängerknoten, der auf dem zuletzt durchlaufenen Weg zum Knoten v liegt. Und
enthält distance[i] die bisher für v ermittelte Entfernung vom Startknoten. Die
Initialwerte sind parent[i]=NULL und distance[i]=0. Am Schluss weist distance[i] den
kürzesten Weg des Kontens v vom Startknoten s aus. Die Gewichte liegen als floatWerte in den jeweiligen Kanten vor.
Für die Speicherung der Randknoten ist eine Prioritätswarteschlange am geeignetsten.
Jeder Record der Schlange merkt einen Randknoten und dessen bisher ermittelten
Abstand vom Startknoten. Die Records seien Objekte der Klasse PriorityRecord. Wir
interpretieren den Abstand als Schlüssel (Priorität) und den Randknoten (Typ
- 99 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
VPosition) als zugehörigen Wert eines solchen Records und führen die
Prioritätswarteschlange als Objekt PriorityQueue ein. Die Operation FindMin der
Klasse PriorityQueue liefert den Record mit dem minimalen Prioritätswert, d.h. dem
kürzesten Abstand vom Startknoten. Die Elementfunktionen GetVertex() und GetKey()
der Klasse PriorityRecord bestimmen in einem Record dieses Typs den Randknoten
und seine bisherige kürzeste Entfernung vom Startknoten. Zu Beginn wird die
Prioritätswarteschlange durch einen ersten Eintrag für den Startknoten s mit dem
Abstandswert NULL initialisiert.
Das Programm Dijkstra entnimmt in einer äußeren Schleife den jeweils nächsten
Eintrag aus der Prioritätswarteschlange. Dieser bezeichnet unter allen Randknoten
denjenigen mit dem kürzesten Abstand zum Startknoten und er wird zum nächsten
inneren Knoten v. In einer inneren Schleife werden dann nacheinander für die Kanten a
des Knotens v der jeweilige Endknoten w bestimmt, für den dann aus dem Abstandswert
des Knotens v, erhöht um den Wert der Kante a, seine Entfernung vom Startknoten
bestimmt wird. Ist w bisher noch unbesucht, wird für ihn ein Eintrag in der
Prioritätswarteschlange mit dem ermittelten Abstandswert vorgenommen. Ist w aber
bereits Randknoten, so werden im Fall eines neuen kürzeren Abstands vom Startknoten
die Werte distance und parent des Knotens sowie die Priorität in der Warteschlange
entsprechend fortgeschrieben.
Void Dijkstra(Graph<Record, float> &D,
VPostition<Record, float>s)
//berechnet die kürzesten Wege in D vom Knoten s
aus
{
int n=D.GetNumVertices(),i,j; //Anzahl
Knoten
PriorityQueue<PriorityRecord,float>q(n);
//Prioritätswarteschlangen für
Randknoten
VPosition<Record,float<v,w;
Aposition<Record,float>a;
PriorityRecord r;
Float *distance=new float[n];
Vposition<Record,float> *parent=new
Vpostition<Record,float>[n];
- 100 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
//Speicherplatz für Array distance und
parent
float distv, dista, distw,distnew;
Ord(D); //Ordnungsnummer Knoten generieren
NotVisited(D); //Knoten unbesucht markieren
For (i=0; i<n; i++)
distance[i]=0;
D.SetVisited(s,true); //s besucht
PriorityRecord *p=new PriorityRecord(s,0);
//Startrecord für Priorityschlange
q.Insert(*p); //speichern in
Prioritätsschlange q
while (!q.IsEmpty()) //Randknoten vorhanden?
{
//JA
q.DeleteMin(r); //nächster Eintrag aus q
nach r
v=r.GetVertex(); //nächster innerer
Knoten v
i=D.GetOrd(v); //Ordnungsnummer des
Randknotens v
distv=distance[i]; //Entfernung v von s
a=D.FirstArc(v); //Erste von v ausgehende
Kante
while (a.Pos())
{
w=D.Endpoint(a); //Endknoten w der
Kante a
j=D.GetOrd(w);
//Ordnungsnummer des Endknoten w
distw= distance[j];
//bisherige kürzeste Entfernung für w
von s
- 101 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
dista=D.GetArc(a); //Abstandswert der
Kante a
distnew=distv+dista; //neue Entfernung
von s für w
if (!D.IsVisited(w))
{
//neuer Randknoten
p=new PriorityRecord(w,distnew);
q.Insert (*p); //neuer Randknoten
D.SetVisited(w,true); //Knoten w
besucht
Parent[j]=v; //v ist der Vorgänger
von w
distance[j]=distnew;
//bisherige kürzeste Entferung von
s für w
}
else //w bereits Randknoten
if (distw>distnew)
{ //neue kürzeste Entfernung für w von
s
p=new PriorityRecord(w,distw);
//Suchargument
q.DecreasePriority(*p,distnew);
//neuen kürzesten Abstand für w in
q eintragen
distance[j]=distnew;
//neue kürzeste Entferung
parent[j]=v; //neuer Vorgänger
}
a=D.NextArc(v,a); //nächste Kante für
Knoten v
}
- 102 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
}
}
Die Prioritätswarteschlange nimmt, da jeder ihrer Records nur einen Knoten enthält,
insgesamt n = V Records auf. Bei der Zeitanalyse für die Prioritätswarteschlange ist
dann von n Insert- und n DeleteMin-Operationen auszugehen. Die innere Schleife wird
für jede der e = E Kanten des Graphen ausgeführt. Dabei wird höchstens eine Insertoder eine IncreasePriority-Operation ausgeführt. Bei Implementation der
Prioritätswarteschlange als Heap kostet jede dieser Operationen O(log n) . Der Aufwand
für den Algorithmus ist somit von der Ordnung O((n + e) log n) .
7.4.1.2.2
ALGORITHMUS VON BELLMANN-FORD
Dijkstras Algorithmus funktioniert nur, wenn die Kantengewichte keine negativen
Werte annehmen können. Dies kann man sich leicht daran verdeutlichen, dass eine lokal
ungünstige nächste Kante durch eine darauf folgende negativ gewichtete Kante
nachträglich zu einer besseren Verbindung führt. Dies kann zum Beispiel für Graphen
die Gewinne und Verlust abbilden sollen, aber zu falschen Ergebnissen führen. Deshalb
wurde der Algorithmus von Bellmann-Ford entwickelt. Dieser funktioniert nach einem
komplett anderen Prinzip: In mehreren Durchläufen wird jeweils die beste bisher
mögliche Verbindung bestimmt, wobei der i-te Durchlauf alle Pfade der Länge i
berücksichtigt. Der längste Pfad ohne Zyklus hat eine Länge von E − 1 , so dass man
diesen Prozess nach E − 1 Durchläufen abschließen kann. Als Optimierung kann man
das Verfahren vorzeitig beenden, wenn in einem Durchlauf keinerlei Änderungen zur
vorherigen Wertebelegung mehr aufgetreten ist.
Algorithm BF(G,s)
//ein Graph G mit einem Startknoten s//
D[s]:=0;
For i:=1 to E − 1 do
For each (u, v) ∈ E do
//gerichtete Kanten//
if D[u ] + γ ((u, v)) < D[v] then
D[v] := D[u ] + γ ((u, v))
fi
- 103 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
od
od
[vgl. Saake/Sattler (2002) S. 427ff]
7.4.1.2.3
KÜRZESTE WEGE FÜR EINEN AZYKLISCHEN GRAPHEN
Der folgende Absatz soll den oben beschriebenen Algorithmus umgelegt auf einen
azyklischen Graphen, welcher in unserer Problemstellung auftritt, zeigen. Damit wird
versucht das Problem und die Lösungsmöglichkeiten näher zu fokussieren.
Wir führen die Rekursion
d ( s, s ) = 0
d ( s, w) = min{d ( s, v) + c(v, w)} für v ∈ V ( w)
mit den topologisch sortierten Knoten direkt aus. Für Graphen der Abbildung 42 bildet
die Folge der Knoten
a–c–b–d–f–e
eine topologische Ordnung. Wir nehmen den ersten Knoten der Ordnung als
Startknoten.
Schrittfolge
Knoten v
1
a
2
c
3
b
4
d
5
6
f
e
Vorläufiger
minimaler
minimaler
Abstand
Nachfolger w
Abstand
Knoten w von
Knoten w von
s
s
c
2
2
b
4
d
6
b
4
4
d
5
f
8
d
5
5
f
7
e
7
6
f
6
e
7
7
Tabelle 8: Berechnung der kürzesten Wege für einen azyklischen Graphen
[Quelle: Reß/Viebeck (2000) S. 408]
Die Knoten werden nacheinander in topologischer Ordnung betrachtet und es wird
sofort ihre kürzeste Entfernung vom Startknoten s bestimmt. Das Ergebnis zeigt Tabelle
8. Das Programm ShortestPath ermittelt wie das Programm Dijstra die kürzeste
Entfernung eines Knotens v vom Startknoten s sukzessive in der Arrayvariablen
distance[i], i bezeichnet die Ordnungsnummer des Knotens v. Der Initialwert für
distance[i] ist 0; die Bedingung dafür ist !D.IsVisited(v). Immer dann, wenn sich durch
- 104 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Hinzunahme des nächsten Knotens ein kürzerer Abstand von s ergibt oder sich in
distance[i] noch der Initialwert befindet, wird der bisherige Wert durch den neuen
ersetzt. Die Knoten werden in Folge ihrer topologischen Ordnung berechnet. Zum
Schluss stehen im Array distance für alle Knoten des Graphen die kürzesten vom
Startknoten s ausgehenden Wege. Die Laufzeit des Programms ist O(n * e) .
Void ShortestPath(Graph<Record,float> &D)
{
unsigned n=D.GetNumVertices(),i,j;
VPosition<Record,float>v,w;
APosition<Record,float>a;
VPosition<Record,float>*ord=new
VPosition<Record,float>[n];
//Knoten in Sortierordung
float *distance=new float[n];
//bisher kürzeste Abstände
float dista,distnew;
TopSort(D); //topologisches Sortieren
NotVisited(D); //Knoten unbesucht
v=D.FirstVertex(); //Initalisieren Arraywerte
while (v.Pos())
{
i=D.GetOrd(v); //Sortierindex Knoten v
ord[i]=v; //Knoten v in Array ord
distance[i]=0;
v=D.NextVertex(v);
}
for (i=0; i<n; i++)
{
v=ord[i]; //Knoten v
a=D.FirstArc(v); //erste Kante von Knoten
v
while (a.Pos())
- 105 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
{
w=D.Endpoint(a); //Endpunkt w der
Kante a
j=D.GetOrd(w); //Index vom Endknoten
dista=D.GetArc(a); //Wert dista von
Kante a
distnew=distance[i]+dista;//Entfernung
w von s
if (!D.IsVisited(w))
{//Knoten noch unbesucht
D.SetVisited(w,true); //Konten
besuchen
distance[j]=distnew; //Entfernung
setzen
}
else
if (distnew<distance[j])
distance[j]=distnew;
//neue kürz. Entferung
a=D.NextArc(v,a);
}
}
}
7.4.1.3
KÜRZESTE WEGE ZWISCHEN ALLEN KONTEN IM GRAPHEN
Die Aufgabe, für jedes Knotenpaar v und w im Graphen D den kürzesten Weg von v
nach w zu berechnen, ließe sich natürlich lösen, dass der Algorithmus von Dijkstra
iterativ auf jeden Knoten des Graphen angewendet wird. Es gibt aber einen einfacheren
Algorithmus, welcher das Problem direkt löst. Zusätzlich gilt der Algorithmus
allgemein für beliebig bewertete Graphen, d.h. auch im Fall negativer Gewichte. Der
Ansatz ist ähnlich dem das Verfahrens von Wahrshall und beruht auf der Idee,
ausgehend für ein beliebiges Knotenpaar vi und vj festzustellen, ob es einen oder
mehrere Wege von vi nach vj gibt und welches der kürzeste ist. Ausgehend von der
- 106 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Kostenmatrix C0 [i, j ] wird dieser Prozess so lange wiederholt, bis sich die Matrix nicht
mehr ändert. Die letzte Matrix enthält dann die kürzesten Wege zwischen je zwei
Knoten von D.
Für C0 gilt: C0 [i, j ] = 0 und C0 [i, j ] = ∞ , falls keine Kanten von vi nach vj existiert.
Beim Übergang von C k −1[i, j ] nach Ck [i, j ] sind zwei Fälle zu unterscheiden:
Es wurde noch kein Weg von vi nach vj festgestellt, d.h. C k −1[i, j ] = ∞ . Gibt es einen
Weg von vi nach vk und einen Weg von vk nach vj, so führt auch ein Weg von vi nach vj .
Es wird Ck [i, j ] = C k −1[i, k ] + C k −1[k , j ] .
Abbildung 43: Darstellung der Knoten und Kanten
Es existiert ein Weg von vi nach vj , d.h. H k −1[i, j ]! = ∞ , und ein weiterer, der über vk
führt und kürzer ist. Dann wird Ck [i, j ] = C k −1[i, k ] + C k −1[k , j ] .
Der Algorithmus von Floyd setzt die Kostenmatrix des Graphen voraus. Das Zeichen ∞
wird durch die größte Zahl des Datentyps der Kantenwerte simuliert.
void Floyd(Graph<Record,float> &D)
{
int n=D.GetNumVertices(),i,j=0,k;
int iter=1;
float C=new float[n*n],h;
boolean b;
D.CostMatrix(C); //Initialisierung
for (i=0;i<n;i++) //C[i,j] =0 setzen
{
C[j]=0;
j+=n+1;
}
while (1)
{
b=false;
- 107 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
for (i=0;i<n;i++)
for (j=0;j<n;j++)
{
if (j==i) continue;
for (k=0;k<n;k++)
{
if (k==i || k==j) continue;
if (C[i*n+k]==MAXFLOAT ||
C[k*n+j]==MAXFLOAT) continue;
else
{
h=C[i*n+k]+C[k*n+j];
if (h<C[i*n+j])
{
C[i*n+j]=h;
b=true; //Matrix geändert
}
}
}
}
if (!b) break; //Änderung der Matrix C?
iter++;
}
}
[vgl. Reß/Vieböck (2000) S. 410ff]
7.5 KOSTENBASIERENDE ABFRAGEBEARBEITUNG IN
RELATIONALEN SYSTEMEN
SQL als nicht-prozedurale und mengenorientierte Zugriffsprache für relationale
Datenbanksysteme ist unter anderem dadurch charakterisiert, dass in einem SQL- 108 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Statement nur beschrieben wird, welche Daten der Benutzer bzw. das
Anwendungsprogramm vom Datenbanksystem geliefert haben möchte. Es wird in
keinem Fall im SQL-Statement beschrieben, wie das Datenbanksystem diese Daten
finden soll. Dies ist die Aufgabe eines so genannten Zugriffs-Optimierers oder englisch
Query Optimizer.
Da in der entwickelten Software für die Planung des Aufbaues eines Datawarehouse mit
Microsoft SQL eine relationale Datenbank als Basis definiert wurde, sind die Kosten für
die Abfrage ein Punkt, welcher beleuchtet werden muss. Dabei soll es meiner Software
möglich sein, durch die Eingaben des Benutzers näherungsweise Aussagen über die
benötigte Zeit der Abfrage zu liefern. Die Kalkulation dieser Kosten wird im Normalfall
vom Query Optimizer durchgeführt. Leider veröffentlichen Datenbankhersteller die
Kostenfunktionen, bzw. die Funktionalität dieser Query Optimizer nicht, da die
Performance eines Datenbankmanagementsystems im entscheidenden Maße von der
Arbeitsweise des jeweiligen Optimizers abhängt. Im Gegenteil, die Funktionen und
Arbeitsweise des Query Optimizers werden von den Datenbankherstellern als
Betriebsgeheimnis angesehen. [vgl. Müller-Angstenberger (1994) S. 1]
Durch diese Geheimhaltung sind in der Literatur nur grobe Schätzverfahren über die
Kosten, bzw. die Abfragezeit einer Abfrage vorhanden. Diese zum Teil sehr
unterschiedlichen Ansätze will ich nun vorstellen.
Heuristische Optimierungstechniken sind darauf ausgerichtet, in der Mehrzahl der Fälle
innerhalb kurzer Laufzeit gute Ergebnisse – d.h. nahezu optimale
Anfrageauswertungspläne – zu liefern. Ein Kostenmodell stellt Funktionen zur
Verfügung, die den Aufwand, d.h. die Laufzeit, der Operatoren der physischen Algebra
abschätzen. Dazu werden diverse Parameter wie Indexe, Ballungen, Kardinalitäten und
Verteilungen benötigt. [vgl. Kemper/Eickler (1996) S. 211f]
Abbildung 44: Funktionsweise eines Kostenmodells [Quelle: Kemper/Eickler (1996) S. 212]
- 109 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Grundsätzlich muss entschieden werden, ob die Daten sequentiell oder über einen Index
gesucht werden sollen. Voraussetzung für einen Indexzugriff ist selbstverständlich das
Vorhandensein eines geeigneten Index. Stehen für den Zugriff prinzipell mehrere
Alternativen zur Auswahl, so wird der Optimizer abschätzen, welche Zugriffsmethode
die günstigere, d.h. die kostengünstigere ist. Dazu dient laut Müller-Angstenberger
(1994) folgende Formel:
Kosten des Zugriffs = X * Anzahl IOs + Y * CPU Verbauch
Dieses grobe Modell besagt, dass pro Zugriff die Kosten der zu erwartenden IOs sowie
die Kosten des zu erwartenden CPU Verbrauchs geschätzt und gewichtet werden. Das
Ergebnis sind die geschätzten Gesamtkosten. [vgl. Müller-Angstenberger (1994) S. 2]
Die Kosten aller Zugriffe ergeben sich somit aus der Summe der Einzeloperationen. Das
gewählte Maß kann, bevor die Anfrage tatsächlich ausgeführt worden ist, nur geschätzt
werden. Eine exakte Bestimmung setzt die Durchführung der Anfrage voraus, da nur
dadurch die getroffenen Annahmen über die Verteilung der Daten auf dem
Sekundärspeicher überprüft werden können. Ein solches Maß ist laut Dunemann (2002)
„die Anzahl der Festplattenzugriffe, da anzunehmen ist, dass dieser Wert mit der
Gesamtlaufzeit der Anfrage korreliert. Hierzu wird zum einen unterstellt, dass
Verarbeitungen im Hauptspeicher so schnell ablaufen, dass sie einen vernachlässigbar
geringen Anteil an der Beantwortungszeit der Anfrage ausmachen. Zum anderen wird
bei einer Anfrage angenommen, dass das Ergebnis nicht wieder auf die Festplatte
geschrieben wird, sondern von einer Applikation konsumiert wird. Somit kann für die
Kostenschätzung auf die Eigenschaften der Eingangsdatenmengen abgestellt werden,
während die Form des Ergebnisses nur für die Kosten der nachfolgenden Operationen
relevant ist.“ [vgl. Dunemann (2002) S. 56]
Einen ähnlichen Ansatz finden Harinarayan et al. (1996), welche die Abfragezeit als
proportional zur Anzahl der Zeilen ansehen, die abgearbeitet werden [Harinarayan et al.
(1996) S. 4].
Dabei wird folgendes lineares Kostenmodell entwickelt:
T=m*S+c
Dabei ist T die Laufzeit der Anfrage mit der Größe S. Und c gibt die Fixkosten (fixe
Zeit) wieder. In dem empirischen Modell ermittelten Harinarayan et al. beispielhaft die
Fixkosten mit 2.07 Sekunden durch experimentelles Austesten in einer Datenbank. m ist
das Verhältnis der Abfragezeit zu der Größe S der Abfrage nach Abzug der Fixkosten.
In der Tabelle werden die Ergebnisse von Harinarayan et al. präsentiert:
- 110 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Source
From cell itself
From view (supplier)
From view (part, supplier)
From view (part, supplier, customer)
Size
1
10000
800000
6000000
Time (sec.) Ratio
2,07 not applicable
2,38
0,000031
20,77
0,000023
226,23
0,000037
Tabelle 9: Entwicklung der Query Response Time im Verhältnis zur Size
[Quelle: Harinarayan et al. (1996) S. 11]
Es gibt eine Reihe unterschiedlicher heuristischer Ansätze, wie die Kosten für eine
Anfrage geschätzt werden können. Zur Schätzung der Eingangsdatenmenge ist aber
zumeist auch die Menge der selektieren Tupel in der Gesamtmenge von Belang. Kessler
(1997) teilt dabei die Schätzverfahren, welche die Anzahl der Tupel einer Relation, die
ein bestimmtes Selektionsprädikat erfüllen, schätzen, in fünf prinzipielle
Vorgehensweisen ein [vgl. Kessler (1997) S. 182ff]:
•
Es wird eine Gleichverteilung der Attributwerte angenommen. Mittels
Statistikformeln wird die Zahl der Tupel geschätzt. Dabei wird eine
Gleichverteilung der Attributwerte angenommen und für jede Relation und jedes
Attribut die Anzahl der Tupel in der Relation, die Anzahl verschiedener
Attributwerte, der kleinste Attributwert, der größte Attributwert und die
Intervallbreite (entspricht größter minus kleinster Attributwert) ermittelt und in
einer Min-Max-Statistik gespeichert. Ausgehend von diesen Werten wird die
Selektivität der einzelnen Prädikattypen geschätzt und durch Multiplikation von
der Anzahl der Tupel in der Relation und Selektivität die erwartete Anzahl der
qualitativen Tupel geschätzt.
•
Es wird eine Ungleichverteilung, die durch eine geeignete
Wahrscheinlichkeitsverteilung approximiert werden kann, angenommen. Die
Zahl der Tupel wird wieder durch Anwendung von Formeln der Statistik
geschätzt. (siehe letzter Absatz)
•
Die Ungleichverteilung der Attributwerte wird durch ein Histogramm
beschrieben. Aus diesem wird die Zahl der Tupel berechnet. Grundsätzlich
lassen sich vollständige und komprimierte Histogramme unterscheiden. In einem
vollständigen Histogramm wird von jedem einzelnen Attributwert erfasst, wie
oft er auftritt. Der Vorteil dieser Histogramme ist ihre Exaktheit. Der Nachteil
ist die große Datenmenge, welche zu speichern ist. In einem komprimierten
- 111 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Histogramm wird die Datenmenge eingeschränkt, indem das Gesamtintervall in
n halboffene, nicht notwendigerweise gleich große Teilintervalle aufgeteilt wird.
Für jedes Teilintervall i wird ein Eintrag erzeugt. Dieser enthält den größten
Attributswert, die Anzahl der Tupel und die Anzahl verschiedener Attributwerte
im Intervall. Zusätzlich wird ein Eintrag (Teilintervall 0) mit der unteren Grenze
des Intervall 1 angelegt.
•
Es wird keine Annahme über die Attributwertverteilung gemacht. Die Zahl der
qualifizierten Tupel wird durch Multiplikation der Gesamtzahl der Tupel mit
einer für die einzelnen Prädikatstypen heuristisch festgelegten Selektivität
ermittelt.
•
Zum Zeitpunkt, zu dem eine Anfrage optimiert wird, wird auf die Relation
zugegriffen und aus ihr eine Stichprobe, bestehend aus einer bestimmten Anzahl
Tupel, entnommen. Ausgehend von dieser Stichprobe wird hochgerechnet, wie
viele Tupel sich insgesamt qualifizieren werden.
Die unterschiedlichen Ansätze zielen alle auf eine Kostenschätzung durch die
Schätzung der Seitenzugriffe ab. Da in unserem Datawarehouse für das Materialisieren
der Würfel typischerweise so genannte GROUP BY Abfragen durchgeführt werden,
werden alle Tupel, bzw. Blöcke des Tables gelesen. Somit ergibt sich die Anzahl der
Readoperationen RS für das Scannen des Table aus
RS = Anzahl der Tupel im Table count(r)/ Anzahl der Tupel pro ReadBlock
Ein ähnlicher Ansatz findet sich auch bei Kessler (1997).
Zusätzlich werden jedoch noch Read Operationen für die GROUP BY Operation
benötigt. Dabei kann die Schätzfunktion von Dunemann (2002) verwendet werden.
⎛ count (r )
⎞
count ( γL (r )) ≈ min⎜⎜
, ∏ (distinct (r , a ) )⎟⎟
2
a∈L
⎝
⎠
[vgl. Dunemann (2002) S. 74]
Damit sagt Dunemann, dass die Anzahl der Tupel einer GROUP BY Operation gleich
dem Produkt der einmaligen Einträge der Tabellen sind oder wenn diese nicht bekannt
mit der halben Tupelanzahl geschätzt wird. Diese sind in meiner Software durch den
Benutzer einzugeben und in der Regel bekannt. So weiß der Benutzer, welcher eine
- 112 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
GROUP BY Abfrage über Kundengruppe und Mitarbeiter haben möchte, sowohl die
Anzahl der Kundengruppen als auch die Anzahl der Mitarbeiter. Für im Zeitablauf
ändernde Voraussetzungen beim Aufbau des Warehouse ist eine Anpassung der
Struktur durchzuführen. Denn eine Zunahme der Anzahl der Mitarbeiter führt zu einer
Veränderung der Struktur und kann eine veränderte Auswahl der materialisierten
Würfel bedeuten.
Des weiteren muss die Sortierung der GROUP BY Ergebnisse beachtet werden. Dabei
hängt nach Dunemann die Zeit für die Sortierung sehr stark von der Verfügbarkeit des
Hauptspeichers ab. Kann dieser alle zu sortierenden Tupel aufnehmen, erfolgt die
Sortierung nach dem Einlesen ohne weitere Plattenzugriffe. Die Kosten sind also
identisch mit der eines Scans. Ist der Hauptspeicher nicht ausreichend, muss ein anderes
Verfahren zum Einsatz kommen, welches auf der Festplatte sortiert. So kann das
Verfahren Merge-Sort, welches bei großen Datenbeständen Einsatz findet, mit
folgenden geschätzten Kosten verwendet werden:
cos t E ( MergeSort (rclustered )) = 3 * blocks(rclustered )
[vgl. Dunemann (2002) S. 60]
Dabei ergeben sich die Kosten einer Sortierung durch die Multiplikation der Anzahl der
Clustered Blocks mit drei. Wenn man diese Kostenschätzung auf die GROUP BY
Anfrage anwendet, wäre dies:
cos t E ( MergeSort L (cube)) = cos t E (FactScands ( cube ) (cube )) + 2 * cos t E (FactScanlocal (cube ))
Damit wären die Kosten für eine GROUP BY Abfrage einmal das Lesen des gesamten
Abfragewürfels und zwei mal die IO Kosten (Schreiben und Lesen) für den neuen
materialisierten Würfel. [vgl. Dunemann (2002) S. 165]
Die komplettesten Ansätze, speziell auf die Bewertung der CPU Kosten in GROUP BY
Abfragen von Datawarehouse Systemen zugeschnitten, finden sich bei Jianzhong
(1999). Sie definieren R(D1, D2, …, Dn; M) als eine multidimensionales Dataset. Die
Dimensionsreihenfolge von R ist dabei Di1 , Di2 ,..., Din und Di j entspricht dem i-ten
Element in der j-ten Dimension. Die Aggregation von R(D1, D2, …, Dn; M) ergibt eine
Group-by Dimensionsmenge {A1 , A2 ,..., Ak } ⊆ {D1 , D2 ,..., Dn } und eine
Aggregationsfunktion F. Damit ist S ( A1 , A2 ,..., Ak ; F ( M ) ) das Ergebnisset, wo die
- 113 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Kosten F(M) durch die Kennzahlen von R in die Aggregationsfunktion F eingesetzt und
errechnet werden.
Jianzhong et al. (1999) beschreiben mehrere Aggregationsalgorithmen. Allerdings
betreffen diese Algorithmen komprimierte Daten, sodass einige Dekomprimierungsbzw. Komprimierungsschritte in den Kostenfunktionen angeführt werden, welche nicht
unbedingt notwendig sind. Ich möchte den von ihnen vorgestellten G-Aggregationsalgorithmus, den M-Algorithmus und den Prefix-Algorithmus hier erwähnen. G steht
dabei für „genereller“ Algorithmus, da er in allen Situationen eingesetzt werden kann.
Dabei wird die Transpositionsphase und die Aggregationsphase unterschieden. Der MAggregationsalgorithmus beschreibt die G-Aggregation in dem Fall, wenn das
Aggregationsergebnis in den Speicher passt. Der Präfix-Algorithmus hat den Vorteil
durch die Situation, dass die Group by Dimensionen ein Prefix der Dimensionsordnung
D1 , D2 , K , Dn des Datasets R(D1 , D2 , K , Dn ; M ) ist. Dadurch kann die Aggregation in
einem Schritt im Hauptspeicher durchgeführt werden.
Abbildung 45: Beispielhafte Arbeitsabfolge im G-Algorithmus [Quelle: Jianzhong (1999) S. 654]
Die Kostenschätzungen der Algorithmen für die CPU Kosten lauten wie folgt:
⎛
⎡
⎡N ⎤
⎡ N ⎤ ⎤ ⎞⎟
CPU G = 2 Nn + ⎢ ⎥ B log 2 B + ⎜⎜ N + 2 N r ⎢log w ⎢
⎥⎦ ⎥ ⎟ log 2 W
BW
⎣B⎦
⎣
⎣
⎦⎠
⎝
CPU M = 2 Nn + Nh + N r
CPU Pr efix = N (2n + 1) + N r
N … Anzahl der Tupel im Abfragetable
n … Anzahl der Dimensionen
- 114 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
B … Anzahl der Tupel pro Block
N r … Anzahl der Tupel in der Ergebnistabelle
W … Anzahl der benötigten Buffer
h … Anzahl der Berechnungen der Hashing Berechnung
[vgl. Jianzhong (1999) S. 653ff]
Dunemann (2002), welcher in seinen Betrachtungen die CPU Kosten für die Abfragen
ignoriert, hat einige bemerkenswerte praktische Untersuchungen über den
Zusammenhang von Größe der BFT (Anzahl der Tupel in der BFT - count facts ) und der
Laufzeit (Kosten) einer GROUP BY Abfrage sowie über den Zusammenhang von der
Größe der Ergebnis-GROUP BY Tabelle (Anzahl der Tupel in den materialisierten
Sichten - count cells ) durchgeführt. Dabei errechnet er die Anzahl der count cells aus einer
Zeitdimension einem Quartal (13 Wochen) sowie 27 Kostenarten, 20
Organisationseinheiten und einer Kennzahl folgende Formel:
count cells = M * Zeit * Kostenart * Organisation
=(1+1)*(13+1)*(27+1)*(20+1)
= 16464
Dabei wird pro Dimension ein Element für undefinierte Werte berücksichtigt. Der
Zusammenhang der Kosten (beziehungsweise der Laufzeit) mit der Anzahl der
count facts ergibt sich nach den Ergebnissen der Tests wie folgt:
count facts 1000
2000
3000
4000
5000
6000
7000
Laufzeit
6,360
8,686
10,790
13,486
16,484
22,063
3,707
Somit ergibt sich ein Korrelationskoeffizient von ρ =0,986. Je dichter dieser Wert bei 1
liegt, desto eindeutiger ist die Korrelation. Ähnliche Tests wurden mit größeren
Tabellen durchgeführt und brachten ähnliche Ergebnisse.
Zur Untersuchung der Korrelation zwischen count cells und der Laufzeit werden durch
Dunemann (2002) folgende Ergebnisse präsentiert:
count cells
16464
31572
47040
62328
77616
92904
Laufzeit
13,486
38,510
67,868
91,401
118,867
135,671
- 115 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Das Ergebnis der linearen Reggressionsanalyse ist ρ =0,998. Damit besteht ein starker
Zusammenhang für Kostenschätzungen. Die Auswertung für die größeren Datenwürfel
bestätigte das Ergebnis, welches für die kleinen Datenwürfel ermittelt worden ist.
Allerdings konnte eine geringere Korrelation festgestellt werden. Deshalb trifft
Dunemann (2002) die Schlussfolgerung, das bei größeren Datenwürfeln der Einfluß der
count cells im Verhältnis zum Einfluss der count facts geringer ist.
[vgl. Dunemann (2002) S.235ff]
Grundsätzlich kann festgestellt werden, dass über die Kostenschätzungen für Abfragen
in der Literatur Uneinigkeit besteht. Dies ist vermutlich darauf zurückzuführen, dass die
Kosten, bzw. die Zeit für eine Abfrage sehr stark von den aktuellen Eigenschaften der
Datenbank abhängen. Trotzdem sind einige Ansätze zu finden, welche ich in einer
weiter unten angeführten Kostenfunktion für meine Berechnungen verwende möchte.
7.6 DIE HEURISTIKEN
7.6.1 EINTEILUNG DER KOSTEN
Um eine Auswahl der zu materialisierenden Würfel treffen zu können, ist es notwendig,
die Kosten für diese Würfel zu berechnen. Dazu habe ich Kostenschätzfunktionen,
welche sehr realitätsnah aber auch nicht zu komplex sein sollen, -da sie die
Grundparameter für die Software darstellen, welche im Lehrbetrieb eingesetzt werden
soll- entwickelt. Diese Kostenschätzfunktionen basieren auf den Ausführungen in
Kapitel 7.5 und haben grundsätzlich auf das Ergebnis der Bewertung der Heuristik
keinen Einfluss. Es ist auch möglich eine Bewertung der Heuristik mit zufällig
hinterlegten Kosten durchzuführen (siehe dazu Kapitel 7.6.5). Ich möchte die
Funktionen aber trotzdem sehr praxisnah ausformulieren, damit die Software nicht nur
für die Lehre und Forschung einsetzbar ist -und nur Aufschluss über die Bewertung der
Heuristiken gibt - sondern auch für die Entwicklung eines richtigen Warehouse
eingesetzt werden kann. Somit liefert die Software realitätsnahe Ergebnisse. Allerdings
ist natürlich diese Kostenfunktion für den praktischen Einsatz nicht ausreichend.
Deshalb erscheint es für Datenbankentwickler sinnvoll ihre geheimen Query Optimizer
Funktionen mit meiner Heuristik zu kombinieren und ein Endanwenderprodukt zu
programmieren. Die Suche nach einer Kostenfunktion ist aber nicht der Kern meiner
Forschung und einer Verbesserung der Kostenfunktion in nachfolgender
Forschungstätigkeit steht jedenfalls nichts im Wege.
Nach meinem Ansatz unterscheide ich zwischen Kosten für die Materialisierung eines
Würfels aus einem anderen Würfel oder dem BFT und den Kosten für das Abfragen
eines Würfels. Diese Unterscheidung ist deshalb essentiell, da die Kosten für die
- 116 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Materialisierung während des Aufbaues des Warehouse auftreten, die Kosten für die
Abfragen jedoch beim Benutzen des Warehouse durch den User (siehe dazu Kapitel
7.3). Es gibt für mich ein Zeitlimit und Speicherplatzlimit auf der Materialisierungsebene. Zusätzlich will ich aber den Ansatz von Prosser durch ein Zeitlimit für Abfragen
auf der Userebene erweitern, da auch die Zeitanforderungen der Benutzer hinsichtlich
Wartezeit auf Ergebnisse einbezogen werden sollten. Dieses Zeitlimit ist aber nicht
zwingend. Das heißt, es kann durchaus die eine oder andere Abfrage länger als die
durchschnittliche gewünschte Wartezeit der User sein. Allerdings ist die
durchschnittliche Abfragedauer aller Abfragen limitiert. Dazu werden die Würfel,
welche für die Benutzer interessant sind, entsprechend der Wartezeit und der
Abfragehäufigkeit klassifiziert.
Somit ergibt sich folgende Kostenfunktion:
Gesamtkosten = Kosten der Abfragephase + Kosten der Materialisierungsphase
7.6.2 KOSTENSCHÄTZFUNKTION DER ABFRAGEPHASE
Ich betrachte hierbei die Kosten für die Abfrage eines Würfels w welcher ein Derivativ
des Würfels v ist. Dieser Würfel w muss also durch eine Abfrage des Würfels v
errechnet werden. Analog ist eine Abfrage eines Würfels w aus dem Base Fact Table zu
sehen. Die Abfrage eines materialisierten Würfels w ist nach meiner Definition 0, da er
nicht errechnet werden muss, sondern bereits aggregiert vorliegt.
7.6.2.1
BEGRIFFSDEFINITIONEN
AnztupelQUERY … Anzahl der Tupel in der abzufragenden Tabelle, bzw. des Joins
AnztupelGROUPBY … Anzahl der Tupel, welche in dem materialisierten View gespeichert
werden
AvTime IO … Durchschnittliche Zeit für die IO Operation eines Tupels
AvTimeCPU … Durchschnittliche CPU Zeit für einen Sortierungsschritt in der Group By
Abfrage
AvtimeMAX …
durchschnittlich verfügbare Zeit pro Abfrage (maximale
durchschnittliche Wartezeit des Benutzers)
- 117 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.6.2.2
•
WERTEBEREICHE UND BEDINGUNGEN
Wertebereich von AnztupelQUERY , AvTimeCPU , AnztupelGROUPBY , AvTime IO
und AvtimeMAX : 0 ≤ x ≤ ∞
7.6.2.3
FUNKTION
⎧ AvTime IO * (AnzTupel QUERY + 2 * ( AnzTupel GROUPBY ))⎫
Kosten = ⎨
⎬+
AvtimeMAX
⎭
⎩
⎧ [AnzTupel GROUPBY * log 2 AnzTupel GROUPBY ]* AvTimeCPU ⎫
⎨
⎬
AvtimeMAX
⎩
⎭
7.6.2.4
BESCHREIBUNG DER KOSTENSCHÄTZFUNKTION
Die Abfragekosten werden mit dem Ausnutzungsgrad der Abfragezeit bewertet. Wenn
also die Benutzer eine Abfragezeit mit durchschnittlich 10 Sekunden benötigen, gibt
eine Aussage der Abfragekosten von 0,8 eine durchschnittliche Abfragedauer von 8
Sekunden an. Dabei werden die Anzahl der Tupel, zuerst beim Table Scan in den
Hauptspeicher gelesen und dann wird der CPU Zeit beim Sortieren und Aggregieren
durch eine Schätzformel berechnet und mit der durchschnittlichen IO Zeit pro Operation
multipliziert. Diese Schätzformel ist stark vereinfacht. Für den Zweck im Lehrbetrieb
gut Ergebnisse zu erhalten aber jedenfalls ausreichend.
7.6.3 KOSTENSCHÄTZFUNKTIONEN DER MATERIALISIERUNGSPHASE
Die Kosten der Materialisierung versuche ich, in Anteilen der durch die
Materialisierung verbrauchten Ressourcen an den Gesamtressourcen, zu berechnen. Je
geringer der Ressourcenverbrauch der Materialisierung, desto kostengünstiger ist die
Materialisierung. Dieser Ansatz ermöglicht die Kosten nicht in absoluten Zahlen, wie
etwa in einer Währung, darzustellen zu müssen. Die realen Kosten einer Abfrage sind
von unzähligen Parametern, wie Datenbankhersteller, Datenbank, Indizes,
Hardewareparametern, Betriebssystemen, usw. abhängig und ändern sich auch im
Zeitablauf.
7.6.3.1
BEGRIFFSDEFINITIONEN
AnztupelQUERY … Anzahl der Tupel in der abzufragenden Tabelle, bzw. des Joins
- 118 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
AnztupelGROUPBY … Anzahl der Tupel, welche in dem materialisierten View gespeichert
werden
AvTime IO … Durchschnittliche Zeit für die IO Operation eines Tupels
AvTimeCPU … Durchschnittliche CPU Zeit für einen Sortierungsschritt in der Group By
Abfrage
AvTime STORE … Durchschnittliche Zeit zum Speichern eines Tupels in dem
materialisierten View
time MAX …
Maximal verfügbare Zeit
space MAX …
Maximal verfügbarer Speicherplatz
AvSizeSTORE … Durchschnittlicher Speicherplatz beim Speichern eines Tupels im
materialisierten View
weight TIME …
Gewichtung der Zeit
weight SPACE … Gewichtung des Speicherplatzes
7.6.3.2
•
WERTEBEREICHE UND BEDINGUNGEN
Wertebereich von AnztupelQUERY , Anztupel STORE , AvTime IO , AnztupelQUERY ,
AvTime STORE , AvSizeSTORE und AvTimeCPU : 0 ≤ x ≤ ∞
•
Wertebereich von time MAX , space MAX : 0 < x ≤ ∞
•
Wertebereich von weight TIME , weight SPACE : 0 ≤ x ≤ 1
•
Es gilt die Nebenbedingung: weight TIME + weight SPACE =1
7.6.3.3
FUNKTION
⎧ AvTimeIO * (AnzTupelQUERY + 2 * ( AnzTupelGROUPBY ))⎫
Kosten = ⎨
⎬ * weightTIME +
Avtime
MAX
⎩
⎭
⎧ [ AnzTupelGROUPBY * log 2 AnzTupelGROUPBY ]* AvTimeCPU ⎫
⎨
⎬ * weightTIME +
AvtimeMAX
⎩
⎭
⎧ AvSizeSTORE * AnzTupel GROUPBY ⎫
⎬ * weight SPACE
⎨
space MAX
⎭
⎩
- 119 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Die Kosten werden durch den Ressourcenverbrauch von Zeit und Speicherplatz
bewertet. Durch die Gewichtungsfaktoren weight SPACE für den Gewichtungsfaktor des
Speicherplatzes und weight TIME für den Gewichtungsfaktor der Zeit kann der Benutzer
die Kosten für Zeit und Speicherplatz gewichten. Der Speicherplatzverbrauch wird in
Anteilen des verbrauchten Speicherplatzes ( AvSizeSTORE * Anztupel STORE ) am
Gesamtspeicherplatz space MAX ausgedrückt.
Auf Seiten der Zeitdimension wird der Zeitverbrauch in Anteilen am
Gesamtzeitverbrauch für die Read/Write Operationen und für die CPU Operationen
berechnet. Dazu wird die Durchschnittliche Zeit für IO Operationen pro Tupel mit der
Anzahl der zu lesenden und schreibenden Tupel multipliziert. Diese Anzahl der Tupel
berechnet sich nach Dunemann (2002) (siehe auch Kapitel 7.5) für eine GROUP BY
Abfrage einmal durch das Lesen des gesamten Abfragewürfels und zwei mal die IO
Kosten (Schreiben und Lesen) für den neuen materialisierten Würfel. Der Anteil des
Zeitverbrauches durch das Sortieren der Group by Tupels wird durch die Anzahl der
Sortierungsschritte multipliziert mit der durchschnittlichen CPU Zeit pro
Sortierungsschritt geschätzt und anschließend gewichtet.
7.6.3.4
BESCHREIBUNG DER KOSTENSCHÄTZFUNKTION
Die Materialisierungskosten werden in Anteilen am Ressourcenverbrauch bewertet und
anschließend noch nach ihrer Wichtigkeit bewertet. So kann der Benutzer stufenlos
entscheiden, ob er das Speicherplatzlimit oder das Zeitlimit höher bewerten will. Die
Berechnung der Zeit ergibt sich durch Addieren der Zeit für das Abfragen, für die
Group by Abfrage des Würfels und der Zeit für das Speichern des neuen Würfels in der
Datenbank. Der Speicherplatz wird einfach durch Multiplikation der durchschnittlichen
Größe eines Tupels mit der Anzahl der zu speichernden Tupel ermittelt.
7.6.4 GESAMTKOSTEN
Die Gesamtkosten ergeben sich durch Addieren und Gewichten der Abfragekosten und
der Materialisierungskosten.
7.6.4.1
BEGRIFFSDEFINITIONEN
KostenQUERY n … Kosten der Abfrage
KostenMATERALISIERENm … Kosten der Materaliserung des zu materialisierenden Würfels m
weight QUERY …
Gewichtung der Abfragekosten
- 120 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
weight MATERALISIEREN …Gewichtung der Materalisierungskosten
… Zähler aller zu materialisierenden Würfel
m
Anz n …
Häufigkeit der Abfrage n durch den Benutzer pro Zeitintervall
… Zähler aller abzufragenden Würfel
n
7.6.4.2
WERTEBEREICHE UND BEDINGUNGEN
•
Wertebereich von KostenQUERY n , KostenMATERALISIEREN m , n , m, Anz n : 0 ≤ x ≤ ∞
•
Wertebereich von weight QUERY , weight MATERALISIEREN : 0 ≤ x ≤ 1
•
Es gilt die Nebenbedingung: weight QUERY + weight MATERALISIEREN =1
7.6.4.3
FUNKTION
[
]
Kosten = ∑ KostenQUERYn * Anz n * weight QUERY + ∑ Kosten MATERALISIEREN
n
m
* weight MATERALISIEREN
m
7.6.5 ZUFÄLLIGE KOSTEN
Um eine wissenschaftlich fundierte Aussage über die Wertigkeit und Funktionalität der
Heuristik zu treffen, will ich ein Austesten der Heuristik mit zufällig gewählten Kosten
durchführen. Dies soll auch die Unabhängigkeit der Heuristik von den
Kostenschätzfunktionen unterstreichen. Dabei können die Kosten grundsätzlich völlig
unstrukturiert zufällig gewählt sein und die Heuristik muss die gleichen Ergebnisse
liefern als die deterministische Lösung. Allerdings will ich, um die Kosten an die realen
Verhältnisse anzupassen, einige Nebenbedingungen beachten.
- 121 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 46: Schematische Aufstellung der Würfel und Kostenfunktionen
In Abbildung 46 gebe ich eine Aufstellung eines exemplarischen Kostenbaumes. Ich
unterscheide Würfel der ersten Ebene V, welche nur aus dem BFT materialisiert werden
können, und Würfel der zweiten Ebene W, welche aus dem BFT oder aus einem Würfel
der Ebene V materialisiert werden können. Diese Aufstellung kann natürlich um
beliebige Ebenen erweitert werden. Dabei gehe ich von folgenden Grundannahmen aus:
•
Eine Kostenfunktion f() symbolisiert Kosten für die Materialisierung oder die
Abfrage eines Würfels, in welchem eine Kante endet aus dem Würfel oder dem
BFT, aus welchem die Kante entspringt.
•
Die Kosten für die Materialisierung oder die Abfrage eines Würfels der Ebene V
ist immer größer als die Kosten für die Materialisierung oder die Abfrage eines
Würfels der Ebene W direkt aus dem BFT, wenn die Anzahl der Group by
Dimensionen von V größer ist als die Anzahl der GROUP BY Dimensionen von
W. Das ergibt sich daraus, dass die CPU Kosten für eine Berechnung höher sind
und die Größe der Ergebnistabelle V wesentlich mehr Tupels enthält. Haben V
und W gleich viele GROUP BY Dimensionen hat V immer mehr Tupels als W in
der Ergebnistabelle. Deshalb ist auch bei gleicher Anzahl der GROUP BY
Dimensionen f(BFT,W) immer teurer als f(BFT,V).
Forderung: ( f ( BFT ,Vx) f f ( BFT , Wy ) ).
•
Die Kosten für die Materialisierung oder die Abfrage eines Würfels W aus der
Vorgängerebene V ist immer kleiner oder gleich den Kosten für die
- 122 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Materialisierung des Würfels W aus dem BFT. Diese Forderung ergibt sich
daraus, dass ein Aggregat immer weniger Einträge besitzt als der BFT und damit
die Berechnungskosten (Tablescan und CPU Aggregations- und
Sortierungskosten) kleiner sind. Forderung:( f (Vx, Wx) p f ( BFT ,Wx) )
•
Die Kosten für die Materialisierung oder die Abfrage eines Würfels der höheren
Ebene W aus der Vorgängerebene V ist immer kleiner als die Kosten für die
Materialisierung oder die Abfrage eines Würfels der niederen Ebene V aus deren
Vorgängerebene U, wenn es sich um die gleiche Aggregationsdimension
handelt. Das heißt eine Aggregation vom BFT → Kundengruppe ist immer
teurer als eine Aggregation von Kundengruppe → Kunden total . Diese
Forderung ergibt sich daraus, dass z.B. die Abfrage einer Kundendatei mit
50000 Einträgen immer länger dauert als eine Abfrage eines materialisierten
Würfels Kundengruppe mit 5 Einträgen bei 5 Kundengruppen. Da aber eine
nachfolgende Hierarchiestufe nie mehr Einträge haben kann als eine
vorhergehende, ergibt sich oben angeführte Forderung.
Forderung: ( f (Vx, Wy ) p f (Uz, Vx) )
•
Die Kosten für das Materialisieren eines Würfels W1 aus dem Würfel V1 sind
immer höher als die Kosten für das Abfragen des Würfels W1 aus dem
materialisierten Würfel V. Diese Forderung ist schlüssig, da das Materialisieren
auch ein Abfragen beinhaltet. Allerdings sind noch zusätzlich Operationen wie
etwa Speichern, Sortieren, etc. notwendig, welche die höheren Kosten bedingen.
Forderung: Abfragekosten<=Materialisierungskosten
7.6.6 HEURISTIK VON ALEXANDER PROSSER
Prosser führt zwei limitierende Bedingungen in seiner Heuristik an:
•
Das begrenzte Zeitfenster für das Laden der operativen Daten in das Warehouse
und Updaten der materialisierten Würfel (timemax)
•
Die maximal verfügbare Speicherkapazität (spacemax)
Er definiert M als die Menge der materialisierten Würfel und v als den ersten Cube,
welcher materialisiert wird. Da noch kein anderer Würfel bis dato materialisiert wurde,
wird der Cube v direkt aus dem BFT (Base Fact Table) generiert. Dabei fallen die
Materialisierungskosten CM an. Dadurch können alle Cubes, welche Derivate von v
sind, die Cubes w ( w ∈ A(v) ), direkt aus v generiert werden. Das führt bei allen Cubes w
zu einer schnelleren Abfrage. In Extremfällen kann der Geschwindigkeitsunterschied
zwischen einer sofortigen Anzeige und einer Wartezeit von Stunden oder Tagen sein.
Diese Abfragezeit wird durch technische Parameter, Benutzeranforderungen, den
- 123 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Kosten der Erstellung von einem Würfel zum anderen oder direkt aus dem BFT, der
Anzahl der Tables über die ein Join gemacht werden muss, der Anzahl der
Dateneinträge, welche durchsucht werden müssen, dem Grad der weiteren Aggregation
und der Index Struktur, beeinflusst. Ein Query Optimizer kann benutzt werden, um
diese Information zu liefern, welche benutzt werden kann um die Kosten zwischen den
Würfeln δ (v, w) zu schätzen. Die Kosten für die Materialisierung von v aus dem BFT
wären dann C M (v) = δ ( BFT , v) . Analog sind die Kosten für das Materialisieren von w
aus v aus einer Abfrage C Q ( w) = δ (v, w) . Die Kosten für weitere Abfragen und
Berechnungen basierend auf w werden nicht betrachtet, da diese ohnehin anfallen. Als
Berechnungsgrundlage haben wir eine Menge von interessanten Würfeln (required
cubes) und die relative Wichtigkeit f(w) für jeden Würfel. Der marginale Nettoeffekt
E(.), wenn nur v als einziger Würfel im APA betrachtet wird, ist die Differenz zwischen
den Kostenverminderung, durch die Tatsache das alle Derivate w ∈ A(v) von v direkt
aus v anstatt vom BFT berechnet werden können, im Vergleich zu den Kosten für die
Materialisierung von v. Wird v vom BFT als der erste Cube materialisiert gilt:
E ( M = {}, v) = ∑ [ f ( w) * (δ ( BFT , w) − δ (v, w))] − δ ( BFT , v)
w ≠ v, w ∈ A(v)
w
Dabei ist es nicht notwendig w ∈ A(v) auf die interessanten Würfel zu beschränken, da
die uninteressanten Würfel die relative Wichtigkeit von f(w) = 0 haben. Die Kosten für
die Materialisierung der Menge M = {v} beträgt somit
C ( M ) = δ ( BFT , v) +
∑ f (w) * δ ( BFT , w) + ∑ f (w) * δ (v, w)
w∉A ( v )
w≠v
w∈A ( v )
Deshalb kann das Optimierungsproblem definiert werden als:
min → C (M ), s * t * space(M ) ≤ space
max
, s * t * time( M ) ≤ timemax
M
Für dieses Problem definiert Prosser die Heuristik wie folgt:
Berechne E(BFT,v) für jeden Würfel im APA und definiere v mit dem höchsten
E(BFT,v) als ersten Würfel welcher M zugesetzt wird. Somit ist M1={v}
Führe die folgende Prozedur durch:
Spaceortime_limit_reached ← false
/* k is used as a counter for the iterations */
k=1
do until spaceortime_limit_reached=true
- 124 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
// define the set of all cubes which can be derived from any materialized cube
at stage k
define A( M k ) =
U A( x)
x∈M k
/* the net effect of each single cube which has not been materialized yet is
computed*/
do for all w ∈ M k
/* the u ∈ A(w) may already be in the derivative set of materialized
cubes */
^
define U k ( w) = {u / u ∈ A( w)^ u ∈ A( M k )}
define U k ( w) = {u / u ∈ A( w)^ u ∉ A( M k )}
/* is cube w itself a derivative of another cube which has already been
materialized?*/
if w ∉ A( M k )
/* no → w can only be built from the BFT */
E ( M k , w) =
∑ [max(0,
u∈Uˆ
∑ [ f (u ) * (δ ( BFT , u ) − δ (w, u ))] +
u∈U
f (u ) * (δ ( x, u ) − δ ( w, u )) | ∀x ∈ M k / u ∈ A( x)
)] − δ ( BFT , w)
else
/* yes → w will be built from the existing cube with the least
distance measure
in that case U k must be empty*/
E ( M k , w) =
∑ [max(0,
u∈U
f (u ) * (δ ( x, u ) − δ ( w, u ) | ∀x ∈ M k / u ∈ A( x) )] −
min (δ ( x, w) | ∀x ∈ M k / w ∈ A( x) )
end if
end do
/* now the net effect off all cubes not materialized at step k is known, the best
one is chosen */
- 125 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
choose w → max(E ( M k , w) )∑ M k +1 = M k ∪ {w}
if space(M k +1 ) ≥ spacemax or time(M k +1 ) ≥ timemax
spaceortime_limit_reached ← true
materialize M k
else k ← k + 1
end if
end do
Der Algorithmus startet mit M 1 = {v} . Danach werden so lange neue Würfel
materialisiert bis entweder das Zeitlimit oder das Speicherlimit erreicht ist. In jedem
Durchlauf wird zuerst k, der Nettoeffekt jedes individuellen Würfels w ∉ M k berechnet.
Da wir an einem Performanceanstieg interessiert sind, welcher sich aus der Möglichkeit
ergibt, die Derivative u ∈ A(w) nun direkt aus w zu erzeugen. Natürlich kann es sein,
dass diese Würfel u auch ein Derivativ eines anderen Würfels x ∈ M k sind, welcher
auch bereits bis zum Durchlauf k materialisiert wurde. Deswegen werden U und Û
entsprechend definiert. Zu beachten ist jedoch, dass beide Werte abhängig von dem
aktuellen Zustand der Menge M k und dem Würfel w, welcher aktuell betrachtet wird,
sind. Dabei werden zwei Fälle unterschieden:
Wenn w kein Derivativ eines Würfels ist, welcher bereits gewählt wurde ( w ∈ A( M k ) ),
ist der Nettoeffekt E ( M k , w) im Durchlauf k
•
für u ∈ U k (w) (also Würfel, welche sonst direkt vom BFT erzeugt
werden müssten) die Kostenersparnis, welche sich durch Erzeugen von u
aus w anstatt direkt vom BFT ( δ (BFT , u ) − δ (w, u ) gewichtet mit f(u))
ergibt.
•
für alle u ∈ Uˆ k ( w) (also Würfel, welche ein Derivative eines bereits für
die Materialisierung ausgewählten Würfels x sind) durch die
Kostenersparnis repräsentiert, welche sich aus dem Erzeugen von u aus
w anstatt aus x ergibt, wobei x bei mehreren Derivativen den Würfel mit
den minimalen Materialisierungskosten repräsentiert. Dabei wird
unterstellt, dass eine Kostenersparnis da ist, sonst wird diese mit 0
bewertet. Daraus ergibt sich die logische Formulierung
max (0, f (u ) * (δ ( x, u ) − δ ( w, u ) ) | ∀x ∈ M k / u ∈ A( x) ) . Diese wird für
- 126 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
alle u ∈ Uˆ aussummiert und wenn dieser Nettoeffekt positiv ist zum
Nettoeffekt von w hinzugezogen.
Da w ∉ A( M k ) wird der Würfel direkt aus dem BFT mit den Kosten δ (BFT , w)
materialisiert.
Wenn w ein Derivative eines Würfels ist, welcher bereits im Durchlauf k für die
Materialisierung ausgewählt wurde, bedeutet dies, dass keine „neuen“ Würfel gebildet
werden können. Die Materialisierung vom w macht also nur dann Sinn, wenn einige
Würfel bedeutend schneller materialisiert werden können als zuvor. Der Nettoeffekt der
Materialisierung von w leitet sich deshalb ab durch:
•
Berechnen der Nettoeffekte für alle u ∈ Uˆ k ( w) wie oben.
•
Berechnen der Erzeugungskosten für w als die minimalen möglichen
Kosten δ ( x, w) aus allen Würfeln x, aus welchen w errechnet werden
kann ( w ∈ A(x) ).
Nachdem der Nettoeffekt aller Würfel w im APA berechnet wurde, wird jener mit dem
maximalen Verbesserungsbetrag gewählt und der Menge M k +1 zugesetzt. Wenn weder
das Zeitlimit oder das Speicherlimit überschritten wird, wird weitergesucht und der
Durchlauf von vorne begonnen. Sonst wird die Suche abgebrochen und M k als
Ergebnismenge der zu materialisierenden Würfeln festgelegt.
7.6.7 HEURISTIK VON THOMAS ACHS
7.6.7.1
PSEUDOCODE DER HEURISTIK
{1. Vorbereitungen für die Iterationen}
Erzeuge Menge R der Required Cubes
Erzeuge Menge D der Derivative Cubes durch Hinzufügen aller
nicht redundanten Würfel, welche mindestens 1 Derivative
haben, welches wiederum in der Menge R enthalten sind.
P=R ∪ D //Vereinige die Menge R und die Menge D zur Menge
P der PossibleCubes für die Materialisierung.
MaxSets:=20; //setzt die maximalen Sets, welche
kontrolliert werden auf 20 – je höher man
- 127 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
diesen Wert setzt umso genauer wird die
Heuristik.
NewSetsforeachiteration:= 3; //bestimmt die zusätzlichen
Sets pro Iterationsstep
Setcounter:=-1; //zählt die aktuellen Wege, welche
kontrolliert werden
Setcount:=1;//Anzahl der Wege
{Ende der Vorbereitungen für die Iterationen}
{2. Iterationen der Sets}
Repeat;
{2.1 Vorbereiten des Startsets für die Iteration}
If Setcounter=-1 then MatCube={}
// Beim ersten Set ist die Menge der bereits
materialisierten Würfel leer
Else begin
//Betrachte das nächste Set und errechne das
verbleibende Limit
MatCube=Sets[Setcounter];
Berechne Limits of MatCube;
End;
{Ende 2.1. Vorbereiten des Startsets für die Iteration}
{2.2. Beginn der Iteration des aktuellen Sets}
While limitreached(MatCube)=false do begin
- 128 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
For each Cube c ∈ P do begin
//Ist der Cube c noch nicht materialisiert
If bereitsmaterialisiert(c)=false then
begin
MinMatCosts:= MatCosts(BFT);
//Die minimalen Materialisierungskosten sind
die Kosten für die Materialisierung des Cubes
aus dem BFT
MerkeMatCube:=BFT; //MerkeMatCube enthält den
Cube aus dem c erzeugt werden kann. Wenn nicht
aus einem bereits materialisierten Cube
abgeleitet werden kann, dann leite aus BFT ab
(Standard)
{2.2.1 Feststellen des Cubes aus dem der Cube c
materialisiert wird: Dazu kontrolliere alle bereits
materialisierten Cubes z, ob c aus z abgeleitet werden
kann}
For each Cube z ∈ MatCube do begin;
if kannabgeleitetwerden(c,z)=true then
begin
//Kann der Cube aus einem bereits
materialisierten Cube z erzeugt werden
//Merke dir den Cube mit den minimalen
Materialisierungskosten
if (MatCosts(z)<MinMatCosts) then begin
MerkeMatCube:=z;
MinMatCosts:= MatCosts(z);
End;
- 129 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
End; //if kannabgeleitetwerden(c,z)
End;//Ende von z ∈ MatCube
{Ende 2.2.1 Feststellen des Cubes aus dem der Cube c
materialisiert wird}
{2.2.2 Festellen der Derivative und der Summe der
Abfragekosten der Derivative für den Cube c}
Summequery:=0; //Die Abfragekosten sind 0
for each Cube x ∈ R do begin
//Kontrolliere alle Required Cubes
if x is derivative von c then begin
//Wenn der required Cube x ein Derivative von c
ist, dann beachte die Querykosten
MinQueryCosts:= QueryCosts(MerkeMatCube);
//Merken der minimalen Querykosten. Diese
sind die Kosten für die Materialisierung
aus dem Vorgänger von c.
MerkeQueryCube:=MerkeMatCube;
//Wenn es keinen besseren Cube y gibt wird
der required cube x aus dem Vorgänger von c
abgefragt, solange c noch nicht besteht.
//Feststellen, ob es einen besseren Cube y
gibt und speichern in MerkeQueryCubes
for Each y ∈ MatCube do begin
If (MinQueryCosts>QueryCosts(x,y)
//Abfragekosten des required Cubes
x aus dem bereits materialisierten
Cube y
then begin
- 130 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
MerkeQueryCube:=y;//Markiere den
Cube y als Abfragecube von x
MinQueryCosts:=QueryCosts(y);
End; //Ende von if
End; //Ende von for Each y ∈ MatCube
{2.2.2.1 Berechnen der Verbesserung der Abfragekosten durch
das Materialisieren von c}
Summequery:= Summequery+max(0,
//Kosten für Abfrage von x
((GetQueryCosts(MerkeQueryCube,x)//Kosten für das Abfragen aus c
GetQueryCost(c,x)))*Häufigkeit der Abfrage);
{Ende 2.2.2.1 Berechnen der Verbesserung der Abfragekosten
durch das Materialisieren von c}
end; //ist ein Derivative
end; //Ende von Each Cube x ∈ R
{Ende 2.2.2 Festellen der Derivative und der Summe der
Abfragekosten der Derivative für den Cube c}
{2.2.3 Berechnen der Verbesserung der Gesamtkosten durch
das Materialisieren von c}
δK(c)=SummeQuery - GetMatCosts(MerkeMatCube);
//Kostenersparnis δK(c) ist die Ersparnis bei den
Abfragen (SummeQuery) minus der
Materialisierungskosten für den Würfel c
- 131 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
{Ende 2.2.3 Berechnen der Verbesserung der Gesamtkosten
durch das Materialisieren von c}
End; //Ende von If bereitsmaterialisiert(c)=false
End;//von each c ∈ P
{2.2.4 Gibt es einen Cube c mit Positivem δK(c)
(Kostenersparnis) und innerhalb der Limits: True- dann
setze den c mit Max(δK(c)) dem aktuellen Set zu; False –
dann schließe das Set ab}
if ( ∀ c ∈ P ∃ max(δK(c))>0)and(Limitreached(c)=false)
then
Begin;
MatCube.add(c)//Addiere den Cube zum aktuellen Set
{2.2.4.1 Gibt es noch NewSetsForEachIteration Cubes,
welche das Limit erfüllen dann wähle die
NewSetsForEachIteration besten Cubes und eröffne neue Sets
solange bis MaxSets erreicht.}
for counter:=1 to Settiefe do begin;
setcount:=setcount+1;
If setcount<MaxSets then AddNewSet;
{Bei AddNewSet wird im neuen Set die Menge
MatCube der bis jetzt materialisieren Würfel
abgelegt. Nur beim letzten Cube, welcher in der
Sequenz hinzugesetzt wird, wird nicht der beste
sonder der zweitbeste, bzw. drittbeste usw Cube
genommen. Das führt dazu, dass bei besonders
schiefen Verteilungen, wo z.B. der erste Würfel mit
Max(δK(c)) nicht in der optimalen Menge der zu
materialisierten Würfel enthalten ist, die
Iteration beim neuen Set nicht in eine falsche
Richtung läuft so wie beim aktuellen Set.}
End;//Ende von Counter
- 132 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
{Ende 2.2.4.1 Gibt es noch NewSetsForEachIteration Cubes,
welche das Limit erfüllen dann wähle die
NewSetsForEachIteration besten Cubes und eröffne neue Sets
solange bis MaxSets erreicht.}
End //Ende von if ( ∀ c ∈ P ∃ max(δK(c))>0) and
(Limitreached(c)=false)
else limitreached:=true;
//Else abbrechen: Gibt es keinen Cube, welcher einen
positiven Kostenbeitrag bringt und in das Limit passt,
dann schließe das Set ab.
{Ende 2.4 Gibt es einen Cube c mit Positivem δK(c)
(Kostenersparnis) und innerhalb der Limits: True- dann
setze den c mit Max(δK(c)) dem aktuellen Set zu; False –
dann schließe das Set ab}
End;//Ende von limitreached=false
{Ende 2.2. Der Iteration des aktuellen Sets}
Sets[Setcounter]:=MatCube;
//Merke dir das neue Set der Materialisierten Würfel
in Sets[Setcounter]
Setcounter:=Setcounter+1;
//Setze den Zeiger auf das nächste Set
Until Setcounter>=MaxSets;
//Die Schleife läuft so lange bis die maximale Anzahl
von Sets (MaxSets – wird vom Benutzer festgelegt)
kontrolliert ist
{Ende 2. Iterationen der Sets}
- 133 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
{3. Berechne die Gesamtkosten für jedes Set}
For Setcounter:=0 to Setcount do begin
CalculateCostsforEachSet(Sets);
End;
{Ende 3. Berechne die Gesamtkosten für jedes Set}
{4. Materialisiere jenes Set mit den minimalen Kosten}
Materialize Set MinCosts(Sets);
{Ende 4. Materialisiere jenes Set mit den minimalen Kosten}
7.6.7.2
BESCHREIBUNG DER HEURISTIK
Zu Beginn wird die Menge P der Possible Cubes berechnet, welche alle Required Cubes
und alle Parent Cubes (Vorgänger der Required Cubes – somit ist der Required Cube
ein Derivative des Parent Cubes) umfasst. Dann wird MaxSets als die Menge der zu
kontrollierenden Sets und NewSetsforEachIteration als Anzahl der neuen Sets pro
Iterationsschritt durch den Benutzer definiert. Der Parameter Setcounter gibt die
Nummer des aktuelle betrachteten Cubesets an und Setcount gibt die Anzahl der bereits
berechneten Cubesets an.
Nach der Vorbereitungsphase wird die Schleife für die Iterationen gestartet
Costimproofmentc =
∑ max{0, [getquery(min(P(x ), x ) − getquery(c, x ))]* Anz }
x
x∈ A ( c )
− getbuild (min (P(c) ), c )
7.6.7.3
DEMONSTRATIVES BEISPIEL
In diesem Abschnitt wird ein demonstratives Beispiel für die Funktionsweise der
Heuristik gegeben. Dabei gehen wir von dem in Abbildung 48 angeführten APA aus.
Die Eingabemaske des Input Screens mit den Dimensionen und Hierarchien findet sich
in Abbildung 47. Wir gehen dabei von einem APA mit 3 Dimensionen und zwei
Hierarchiestufen in der ersten Dimension, drei Hierarchiestufen in der zweiten
Dimension und drei Hierarchiestufen in der dritten Dimension aus. Das ergibt eine
Anzahl von 23 potentiellen Cubes von diesen sind 9 Required Cubes. Das Ergebnis der
Heuristik wird in Abbildung 48 dargestellt. Die Anzahl der maximal möglichen Sets
wurde mit 20 definiert und die maximal mögliche neue Setanzahl pro Iterationsschritt
- 134 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
wurde mit 4 definiert. Im Vorfeld darf jedoch vorweggenommen werden, dass die
Limits so gewählt wurden, dass sich eine Lösung von 6 Cubes ergibt und nur 18
mögliche Lösungswege vorhanden sind. Im Beispiel liefert die Heuristik eine 100 %
richtige Lösung.
Abbildung 47: Dimensionen und Hierarchien des DemoAPA
Abbildung 48: DemoAPA mit Lösung
Die Heuristik beginnt mit der Auswahl der Possible Cubes und dem Starten der
Iteration. Im ersten Durchlauf wird der Fokus auf das Set 1 gesetzt, welches leer ist.
- 135 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Dann beginnt die Iteration. Im ersten Iterationsschritt wird der Gewinn der
Materialisierung eines jeden Cubes unabhängig von den anderen Cubes berechnet. Als
bester Cube (mit der höchsten Gesamtkostenverringerung) würde der Cube 1:3
festgestellt und dem Set 1 zugesetzt.
1. Schritt: Finde den ersten Cube im aktuellen Set (1)
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7
1
1:3
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Costs
Abbildung 49: Schritt 1 der Heuristik nach Thomas ACHS
Als nächstes beginnt die Phase des Zusetzens der nächstbesten Cubes. Dabei wird der
zweitbeste Cube dem Set 2, der drittbeste Cube dem Set 3,der viertbeste Cube dem Set
4 und der fünftbeste Cube dem Set 5 als erster Cube zugesetzt bis entweder kein anderer
Cube einen positiven Kostenbeitrag in der aktuellen Iterationsstufe liefern kann oder die
maximale Anzahl der Cubes, welche zugesetzt werden dürfen
(NewSetsForEachIteration – wird durch den Benutzer definiert) erreicht ist.
- 136 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
2. Schritt: Zusetzen des zweitbesten bis fünftbesten Cubes in neue Sets,
wenn sie positiven Nutzen haben und in das Limit passen
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7
1
1:3
2
0:3
3
1:4
4
2:3
5
0:5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Costs
Abbildung 50: Schritt 2 der Heuristik nach Thomas ACHS
Im Schritt 3 ist nun die erste Iteration abschlossen und nun wird im nächsten Schritt der
Wert aller Cubes unter Berücksichtigung dessen, dass der Cube 1:3 bereits im Set 1
materialisiert wurde, berechnet und der beste ausgewählt. Dies ist der Cube 1:4.
3. Schritt: Finde den nächsten Cube im aktuellen Set (1)
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7
1
1:3
1:4
2
0:3
3
1:4
4
2:3
5
0:5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Costs
Abbildung 51: Schritt 3 der Heuristik nach Thomas ACHS
Dann werden die Sets mit den zweitbesten, drittbesten, usw. Cubes als Cube 2
zugesetzt. An Position 1 steht der beste Cube des ersten Sets.
- 137 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
4. Schritt: Eröffne neue Sets mit den zweitbesten bis fünftbesten Cubes
in Position 2, wenn sie positiven Nutzen haben und in das Limit passen
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7
1
1:3
1:4
2
0:3
3
1:4
4
2:3
5
0:5
6
1:3
2:3
7
1:3
0:5
8
1:3
0:3
9
1:3
2:4
10
11
12
13
14
15
16
17
18
19
20
Costs
Abbildung 52: Schritt 4 der Heuristik nach Thomas ACHS
Beim dritten Iterationsschritt kristallisiert sich der Cube 2:0 als beste Cube für das Set 1
heraus. Deshalb wird dieser dem Set 1 zugesetzt.
5. Schritt: Finde nächsten Cube im aktuellen Set (1)
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7
1
1:3
1:4
2:0
2
0:3
3
1:4
4
2:3
5
0:5
6
1:3
2:3
7
1:3
0:5
8
1:3
0:3
9
1:3
2:4
10
11
12
13
14
15
16
17
18
19
20
Costs
Abbildung 53: Schritt 5 der Heuristik nach Thomas ACHS
Im Anschluss werden wiederum die neuen Sets mit dem nächstbesten Cubes in Phase 3
zugesetzt. Dabei ist zu beachten, dass die ersten beiden Cubes aus dem Set 1
übernommen werden und nur in der letzten Position die nächstbesten Cube zugesetzt
werden.
- 138 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
6. Schritt: Eröffne neue Sets mit den zweitbesten bis fünftbesten Cubes
in Position 3, wenn sie positiven Nutzen haben und in das Limit passen
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7
1
1:3
1:4
2:0
2
0:3
3
1:4
4
2:3
5
0:5
6
1:3
2:3
7
1:3
0:5
8
1:3
0:3
9
1:3
2:4
10
1:3
1:4
0:3
11
1:3
1:4
1:2
12
1:3
1:4
0:5
13
1:3
1:4
0:0
14
15
16
17
18
19
20
Costs
Abbildung 54: Schritt 6 der Heuristik nach Thomas ACHS
In Abbildung 55 (7. Schritt) wird die vierte Iteration gestartet und der Cube 1:2 als der
nächste beste Cube gefunden und dem Set zugesetzt.
7. Schritt: Finde nächsten Cube im aktuellen Set (1)
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7
1
1:3
1:4
2:0
1:2
2
0:3
3
1:4
4
2:3
5
0:5
6
1:3
2:3
7
1:3
0:5
8
1:3
0:3
9
1:3
2:4
10
1:3
1:4
0:3
11
1:3
1:4
1:2
12
1:3
1:4
0:5
13
1:3
1:4
0:0
14
15
16
17
18
19
20
Costs
Abbildung 55: Schritt 7 der Heuristik nach Thomas ACHS
Abermals werden die nächsten besten Cubes in Schritt 8 in den neuen Sets hinzugefügt.
- 139 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
8. Schritt: Eröffne neue Sets mit den zweitbesten bis fünftbesten Cubes
in Position 4, wenn sie positiven Nutzen haben und in das Limit passen
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7
1
1:3
1:4
2:0
1:2
2
0:3
3
1:4
4
2:3
5
0:5
6
1:3
2:3
7
1:3
0:5
8
1:3
0:3
9
1:3
2:4
10
1:3
1:4
0:3
11
1:3
1:4
1:2
12
1:3
1:4
0:5
13
1:3
1:4
0:0
14
1:3
1:4
2:0
0:5
15
1:3
1:4
2:0
0:0
16
1:3
1:4
2:0
2:2
17
1:3
1:4
2:0
1:5
18
19
20
Costs
Abbildung 56: Schritt 8 der Heuristik nach Thomas ACHS
Im fünften Iterationsschritt wird der Cube 2:2 als bester gefunden. Dieser wird zugesetzt
und die Kontrolle der nächstbesten Cubes gestartet.
9. Schritt: Finde nächsten Cube im aktuellen Set (1)
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7
1
1:3
1:4
2:0
1:2
2:2
2
0:3
3
1:4
4
2:3
5
0:5
6
1:3
2:3
7
1:3
0:5
8
1:3
0:3
9
1:3
2:4
10
1:3
1:4
0:3
11
1:3
1:4
1:2
12
1:3
1:4
0:5
13
1:3
1:4
0:0
14
1:3
1:4
2:0
0:5
15
1:3
1:4
2:0
0:0
16
1:3
1:4
2:0
2:2
17
1:3
1:4
2:0
1:5
18
19
20
Costs
Abbildung 57: Schritt 9 der Heuristik nach Thomas ACHS
Die maximale Anzahl der Sets wurde vom Benutzer mit 20 Sets definiert. Dadurch ist
nach dem Zusetzen des zweitbesten Cubes zum Set 18, des drittbesten Cubes zum Set
19 und des vierbesten Cubes zum Set 20 keine weiteren Sets.
- 140 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
10. Schritt: Eröffne neue Sets mit den zweitbesten bis fünftbesten
Cubes in Position 5, wenn sie positiven Nutzen haben (Hinweis: Nach
dem Set 20 ist die maximale Anzahl der Sets erreicht. Neue Sets werden
nur so lange eröffnet, solange es Cubes gibt, die eine positiven Nutzen
bringen und in das Limit passen oder die Anzahl der maximalen Sets
erreicht ist. Deshalb werden keine neuen Sets mehr eröffnet)
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7
1
1:3
1:4
2:0
1:2
2:2
2
0:3
3
1:4
4
2:3
5
0:5
6
1:3
2:3
7
1:3
0:5
8
1:3
0:3
9
1:3
2:4
10
1:3
1:4
0:3
11
1:3
1:4
1:2
12
1:3
1:4
0:5
13
1:3
1:4
0:0
14
1:3
1:4
2:0
0:5
15
1:3
1:4
2:0
0:0
16
1:3
1:4
2:0
2:2
17
1:3
1:4
2:0
1:5
18
1:3
1:4
2:0
1:2
1:5
19
1:3
1:4
2:0
1:2
2:4
20
1:3
1:4
2:0
1:2
3:2
Costs
Abbildung 58: Schritt 10 der Heuristik nach Thomas ACHS
Damit ist die Aufbauphase der Sets abgeschlossen und es erfolgt die Berechnungsphase
für das aktuelle und alle folgenden Sets. Im Moment befinden wir uns noch im Set 1
und suchen den nächsten Cube, welcher den besten Beitrag bringt und in die Limits
passt. Dieser ist 2:4.
11. Schritt: Finde nächsten Cube im aktuellen Set (1)
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7
1
1:3
1:4
2:0
1:2
2:2
2:4
2
0:3
3
1:4
4
2:3
5
0:5
6
1:3
2:3
7
1:3
0:5
8
1:3
0:3
9
1:3
2:4
10
1:3
1:4
0:3
11
1:3
1:4
1:2
12
1:3
1:4
0:5
13
1:3
1:4
0:0
14
1:3
1:4
2:0
0:5
15
1:3
1:4
2:0
0:0
16
1:3
1:4
2:0
2:2
17
1:3
1:4
2:0
1:5
18
1:3
1:4
2:0
1:2
1:5
19
1:3
1:4
2:0
1:2
2:4
20
1:3
1:4
2:0
1:2
3:2
Costs
Abbildung 59: Schritt 11 der Heuristik nach Thomas ACHS
- 141 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Im Schritt 12 finden wir den Cube 2:3 als siebenten Cube des Sets 1, welcher den
höchsten positiven Beitrag zu Kostenverringerung bringt und in die Limits passt.
12. Schritt: Finde nächsten Cube im aktuellen Set (1)
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7
1
1:3
1:4
2:0
1:2
2:2
2:4
2:3
2
0:3
3
1:4
4
2:3
5
0:5
6
1:3
2:3
7
1:3
0:5
8
1:3
0:3
9
1:3
2:4
10
1:3
1:4
0:3
11
1:3
1:4
1:2
12
1:3
1:4
0:5
13
1:3
1:4
0:0
14
1:3
1:4
2:0
0:5
15
1:3
1:4
2:0
0:0
16
1:3
1:4
2:0
2:2
17
1:3
1:4
2:0
1:5
18
1:3
1:4
2:0
1:2
1:5
19
1:3
1:4
2:0
1:2
2:4
20
1:3
1:4
2:0
1:2
3:2
Costs
Abbildung 60: Schritt 12 der Heuristik nach Thomas ACHS
Nach dem Zusetzen des siebenten Cubes findet sich kein Cube mehr, welcher einen
positiven Beitrag bringt und in die Limits passt. Deshalb wird das Set 1 als
abgeschlossen betrachtet und der Fokus auf das Set 2 gelegt.
13. Schritt:Limit im Set 1 erreicht. Setze den Setcounter+1 (=2).
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7
1
1:3
1:4
2:0
1:2
2:2
2:4
2:3
2
0:3
3
1:4
4
2:3
5
0:5
6
1:3
2:3
7
1:3
0:5
8
1:3
0:3
9
1:3
2:4
10
1:3
1:4
0:3
11
1:3
1:4
1:2
12
1:3
1:4
0:5
13
1:3
1:4
0:0
14
1:3
1:4
2:0
0:5
15
1:3
1:4
2:0
0:0
16
1:3
1:4
2:0
2:2
17
1:3
1:4
2:0
1:5
18
1:3
1:4
2:0
1:2
1:5
19
1:3
1:4
2:0
1:2
2:4
20
1:3
1:4
2:0
1:2
3:2
Costs
Abbildung 61: Schritt 13 der Heuristik nach Thomas ACHS
Da nun das Set 2 den Fokus hat, wird analog zum Set 1 immer der beste Cube zugesetzt,
welcher in die Limits passt.
- 142 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
14. Schritt:Berechne das noch vorhandene Limit nach der
Berücksichtigung der bereits im neuen Set enthaltenen Cubes und
starte die Iteration des neuen Sets.
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7
1
1:3
1:4
2:0
1:2
2:2
2:4
2:3
2
0:3
3
1:4
4
2:3
5
0:5
6
1:3
2:3
7
1:3
0:5
8
1:3
0:3
9
1:3
2:4
10
1:3
1:4
0:3
11
1:3
1:4
1:2
12
1:3
1:4
0:5
13
1:3
1:4
0:0
14
1:3
1:4
2:0
0:5
15
1:3
1:4
2:0
0:0
16
1:3
1:4
2:0
2:2
17
1:3
1:4
2:0
1:5
18
1:3
1:4
2:0
1:2
1:5
19
1:3
1:4
2:0
1:2
2:4
20
1:3
1:4
2:0
1:2
3:2
Costs
Abbildung 62: Schritt 14 der Heuristik nach Thomas ACHS
Dies wird so lange durchgeführt bis kein Cube mehr dem Set 2 zugesetzt werden kann
und der Fokus wandert auf das Set 3 usw.
15. Schritt: Finde nächsten Cube im aktuellen Set (2)
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7
1
1:3
1:4
2:0
1:2
2:2
2:4
2:3
2
0:3
1:3
3
1:4
4
2:3
5
0:5
6
1:3
2:3
7
1:3
0:5
8
1:3
0:3
9
1:3
2:4
10
1:3
1:4
0:3
11
1:3
1:4
1:2
12
1:3
1:4
0:5
13
1:3
1:4
0:0
14
1:3
1:4
2:0
0:5
15
1:3
1:4
2:0
0:0
16
1:3
1:4
2:0
2:2
17
1:3
1:4
2:0
1:5
18
1:3
1:4
2:0
1:2
1:5
19
1:3
1:4
2:0
1:2
2:4
20
1:3
1:4
2:0
1:2
3:2
Costs
Abbildung 63: Schritt 15 der Heuristik nach Thomas ACHS
Im Schritt 95 sehen wir das bereits fast vollendete Lösungsgitter der Sets 1 bis 20. Das
Set 20 wird im Schritt 97 endgültig abgeschlossen.
- 143 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
95. Schritt: Finde nächsten Cube im aktuellen Set (20)
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7
1
1:3
1:4
2:0
1:2
2:2
2:4
2:3
2
0:3
1:3
1:4
2:0
1:2
2:4
2:3
3
1:4
1:3
2:3
2:0
1:2
2:2
2:4
4
2:3
1:3
1:4
2:0
1:2
2:2
2:4
5
0:5
1:3
1:4
2:0
2:2
2:4
2:3
6
1:3
2:3
0:3
1:4
2:0
1:2
2:4
7
1:3
0:5
1:4
2:0
2:2
2:4
2:3
8
1:3
0:3
1:4
2:0
1:2
2:4
2:3
9
1:3
2:4
2:3
2:0
1:2
2:2
10
1:3
1:4
0:3
2:3
2:0
1:2
2:4
11
1:3
1:4
1:2
2:0
2:2
2:4
2:3
12
1:3
1:4
0:5
2:3
0:3
2:0
2:4
13
1:3
1:4
0:0
2:0
2:4
2:3
14
1:3
1:4
2:0
0:5
2:3
2:4
2:2
15
1:3
1:4
2:0
0:0
1:0
2:4
2:3
16
1:3
1:4
2:0
2:2
1:2
2:4
2:3
17
1:3
1:4
2:0
1:5
2:4
1:2
2:3
18
1:3
1:4
2:0
1:2
1:5
2:4
2:3
19
1:3
1:4
2:0
1:2
2:4
2:2
2:3
20
1:3
1:4
2:0
1:2
2:4
2:2
Costs
Abbildung 64: Schritt 95 der Heuristik nach Thomas ACHS
96. Schritt: Finde nächsten Cube im aktuellen Set (20)
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7
1
1:3
1:4
2:0
1:2
2:2
2:4
2:3
2
0:3
1:3
1:4
2:0
1:2
2:4
2:3
3
1:4
1:3
2:3
2:0
1:2
2:2
2:4
4
2:3
1:3
1:4
2:0
1:2
2:2
2:4
5
0:5
1:3
1:4
2:0
2:2
2:4
2:3
6
1:3
2:3
0:3
1:4
2:0
1:2
2:4
7
1:3
0:5
1:4
2:0
2:2
2:4
2:3
8
1:3
0:3
1:4
2:0
1:2
2:4
2:3
9
1:3
2:4
2:3
2:0
1:2
2:2
10
1:3
1:4
0:3
2:3
2:0
1:2
2:4
11
1:3
1:4
1:2
2:0
2:2
2:4
2:3
12
1:3
1:4
0:5
2:3
0:3
2:0
2:4
13
1:3
1:4
0:0
2:0
2:4
2:3
14
1:3
1:4
2:0
0:5
2:3
2:4
2:2
15
1:3
1:4
2:0
0:0
1:0
2:4
2:3
16
1:3
1:4
2:0
2:2
1:2
2:4
2:3
17
1:3
1:4
2:0
1:5
2:4
1:2
2:3
18
1:3
1:4
2:0
1:2
1:5
2:4
2:3
19
1:3
1:4
2:0
1:2
2:4
2:2
2:3
20
1:3
1:4
2:0
1:2
3:2
2:4
2:3
Costs
Abbildung 65: Schritt 96 der Heuristik nach Thomas ACHS
- 144 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
97. Schritt:Limit im Set 20 erreicht. Setze den Setcounter+1 (=21).
Setcounter überschreitet die Anzahl der Sets (Setcount). Deshalb
beende die Iterationsphase.
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7
1
1:3
1:4
2:0
1:2
2:2
2:4
2:3
2
0:3
1:3
1:4
2:0
1:2
2:4
2:3
3
1:4
1:3
2:3
2:0
1:2
2:2
2:4
4
2:3
1:3
1:4
2:0
1:2
2:2
2:4
5
0:5
1:3
1:4
2:0
2:2
2:4
2:3
6
1:3
2:3
0:3
1:4
2:0
1:2
2:4
7
1:3
0:5
1:4
2:0
2:2
2:4
2:3
8
1:3
0:3
1:4
2:0
1:2
2:4
2:3
9
1:3
2:4
2:3
2:0
1:2
2:2
10
1:3
1:4
0:3
2:3
2:0
1:2
2:4
11
1:3
1:4
1:2
2:0
2:2
2:4
2:3
12
1:3
1:4
0:5
2:3
0:3
2:0
2:4
13
1:3
1:4
0:0
2:0
2:4
2:3
14
1:3
1:4
2:0
0:5
2:3
2:4
2:2
15
1:3
1:4
2:0
0:0
1:0
2:4
2:3
16
1:3
1:4
2:0
2:2
1:2
2:4
2:3
17
1:3
1:4
2:0
1:5
2:4
1:2
2:3
18
1:3
1:4
2:0
1:2
1:5
2:4
2:3
19
1:3
1:4
2:0
1:2
2:4
2:2
2:3
20
1:3
1:4
2:0
1:2
2:4
2:2
2:3
Costs
Abbildung 66: Schritt 97 der Heuristik nach Thomas ACHS
Nachdem alle Sets im Schritt 97 abgeschlossen sind, erfolgt die Kostenberechnung für
jedes Set separat. Dabei wird die Materialisierungsreihenfolge der Cubes entsprechend
eine kostenminimalen Materialisierung berechnet. Deshalb haben auch das Set 1, 3 , 4,
11, 16 und 19 die gleichen Kosten, da es sich im Prinzip um die gleiche Menge an
Cubes handelt, nur in unterschiedlicher Reihenfolge. Die Heuristik berechnet aber die
Kosten immer in der Reihenfolge der minimalen Materialisierungskosten einer Menge.
Aus diesem Grund müssen die gleichen Kosten entstehen.
- 145 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
98. Berechne die Kosten für jedes Set. Diese bestehen aus den
Materialisierungskosten pro Set und den Abfragekosten der Required
Cubes beeinflusst durch die Auswahl des Sets.
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7
Costs
1
1:3
1:4
2:0
1:2
2:2
2:4
2:3
155.136,00
2
0:3
1:3
1:4
2:0
1:2
2:4
2:3
561.381,00
3
1:4
1:3
2:3
2:0
1:2
2:2
2:4
155.136,00
4
2:3
1:3
1:4
2:0
1:2
2:2
2:4
155.136,00
5
0:5
1:3
1:4
2:0
2:2
2:4
2:3
484.339,00
6
1:3
2:3
0:3
1:4
2:0
1:2
2:4
561.381,00
7
1:3
0:5
1:4
2:0
2:2
2:4
2:3
484.339,00
8
1:3
0:3
1:4
2:0
1:2
2:4
2:3
561.381,00
9
1:3
2:4
2:3
2:0
1:2
2:2
135.898,00
10
1:3
1:4
0:3
2:3
2:0
1:2
2:4
561.381,00
11
1:3
1:4
1:2
2:0
2:2
2:4
2:3
155.136,00
12
1:3
1:4
0:5
2:3
0:3
2:0
2:4
966.857,00
13
1:3
1:4
0:0
2:0
2:4
2:3
1.483.283,00
14
1:3
1:4
2:0
0:5
2:3
2:4
2:2
484.339,00
15
1:3
1:4
2:0
0:0
1:0
2:4
2:3
1.478.603,00
16
1:3
1:4
2:0
2:2
1:2
2:4
2:3
155.136,00
17
1:3
1:4
2:0
1:5
2:4
1:2
2:3
333.905,00
18
1:3
1:4
2:0
1:2
1:5
2:4
2:3
333.905,00
19
1:3
1:4
2:0
1:2
2:4
2:2
2:3
155.136,00
20
1:3
1:4
2:0
1:2
3:2
2:4
2:3
468.248,00
Abbildung 67: Schritt 98 der Heuristik nach Thomas ACHS
Anschließend wird das Set mit den minimalen Kosten materialisiert. Dieses ist in
unserem Beispiel das Set 9 mit den minimalen Kosten von 135898.
99. Wähle das kostengünstigste Set und materialisiere das Set.
Set Cube1 Cube2 Cube3 Cube4 Cube5 Cube6 Cube7
Costs
1
1:3
1:4
2:0
1:2
2:2
2:4
2:3
155.136,00
2
0:3
1:3
1:4
2:0
1:2
2:4
2:3
561.381,00
3
1:4
1:3
2:3
2:0
1:2
2:2
2:4
155.136,00
4
2:3
1:3
1:4
2:0
1:2
2:2
2:4
155.136,00
5
0:5
1:3
1:4
2:0
2:2
2:4
2:3
484.339,00
6
1:3
2:3
0:3
1:4
2:0
1:2
2:4
561.381,00
7
1:3
0:5
1:4
2:0
2:2
2:4
2:3
484.339,00
8
1:3
0:3
1:4
2:0
1:2
2:4
2:3
561.381,00
9
1:3
2:4
2:3
2:0
1:2
2:2
135.898,00
10
1:3
1:4
0:3
2:3
2:0
1:2
2:4
561.381,00
11
1:3
1:4
1:2
2:0
2:2
2:4
2:3
155.136,00
12
1:3
1:4
0:5
2:3
0:3
2:0
2:4
966.857,00
13
1:3
1:4
0:0
2:0
2:4
2:3
1.483.283,00
14
1:3
1:4
2:0
0:5
2:3
2:4
2:2
484.339,00
15
1:3
1:4
2:0
0:0
1:0
2:4
2:3
1.478.603,00
16
1:3
1:4
2:0
2:2
1:2
2:4
2:3
155.136,00
17
1:3
1:4
2:0
1:5
2:4
1:2
2:3
333.905,00
18
1:3
1:4
2:0
1:2
1:5
2:4
2:3
333.905,00
19
1:3
1:4
2:0
1:2
2:4
2:2
2:3
155.136,00
20
1:3
1:4
2:0
1:2
3:2
2:4
2:3
468.248,00
Abbildung 68: Schritt 99 der Heuristik nach Thomas ACHS
- 146 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.7 DIE DETERMINISTISCHE LÖSUNG
7.7.1 MATHEMATISCHE GRUNDLAGEN
Im Zuge der Bestimmung der deterministischen Lösung ist es notwendig, für alle
möglichen Mengen von materialisieren Cubes die Kosten zu berechnen und die Menge
auszuwählen, welche die geringsten Kosten hat. Dabei spielt die Rangfolge der
materialisierten Cubes in der Menge eine Rolle. Spielt die Anordnung der Elemente in
einer Menge eine Rolle, nennt man diese eine Folge [vgl. Witt (2001) S. 137]. Wenn der
Cube a vor dem Cube b materialisiert wurde und b ein Derivative von a ist, die
Materialisierungskosten für die Folge < a ,b > geringer sind als die
Materialisierungskosten < b,a >. Das führt dazu, dass die Materialisierungssequenz von
enormer Bedeutung sein kann.
7.7.1.1
PERMUTATION
Wir betrachten dabei die Auswahl von Folgen, in denen ein Element höchstens einmal
vorkommen darf. Dies ist schlüssig, da ein Würfel nur einmal materialisiert werden
kann. Bei dieser speziellen Art der Permutation spricht man von der Permutation ohne
Wiederholung [vgl. Witt (2001) S. 137].
Sei M eine Menge mit M = n und k ∈ N 0n . Ein k-Permutation von M ist eine Folge
< x1 ,..., xk > mit xi ∈ M und xi ≠ x j für i ≠ j , mit 1 ≤ i, j ≤ k . Weiters sei P(n, k ) die
Anzahl der k-Permutationen, die aus n-elementigen Menge gebildet werden kann.
n
k −1
i = n − k +1
i =0
P (n, k ) = n(n − 1)(n − 2)...(n − k + 1) =
∏ i = ∏ (n − i ) =
n!
(n − k )!
[vgl. Witt (2001) S. 137f]
7.7.1.2
KOMBINATION
Im Gegensatz zur Permutation spielt bei der Kombination die Reihenfolge der Elemente
in der Menge keine Rolle. Wir gehen wieder von der Kombination ohne Wiederholung
aus, was bedeutet, dass jedes Element in der Menge nur einmal vorkommt.
Sei M eine Menge mit M = n und k ∈ N 0n . Ein k-Kombination von M ist eine
Teilmenge von M mit k Elementen. Weiters sei K (n, k ) die Anzahl der kKombinationen, die aus der Menge M gebildet werden können.
K ( n, k ) =
n!
k!*(n − k )!
- 147 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
[vgl. Witt (2001) S. 141f]
7.7.2 DER ALGORITHMUS FÜR DIE PERMUTATION
{1. Vorbereitungen für die Permutation}
Erzeuge Menge R der Required Cubes
Erzeuge Menge P der Possible Cubes, welche die Menge der
nicht redundanten Würfel umfasst und gib jedem Würfel einen
Nummer.
Erzeuge Countliste (array of longint) als die Teilmenge der
Menge P mit den Nummern der Possible Cubes.
anzcube=count(P) //Gibt die Anzahl der Elemente in der
Menge P der Possible Cubes an.
Alwaysspacemaxreached=true//Abbruchbedingung
Cubepos=1
maxpos=0
aktpos=0
{Ende 1. Vorbereitungen für die Permutation}
if (anzcube>0) then begin
{2. Beginn der Permutationsschleife}
ende=false
While (ende=false) do begin
{2.1. Beginn der Unterpermutationsschleife für den letzten
Zähler}
Repeat
if (Cubepos>anzcube) then begin
{2.1.1 Wenn in der aktuellen Cursorposition das Maximum
erreicht ist}
- 148 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Cubepos=1
Countliste[aktpos]=cubepos;
aktpos=aktpos+1
if aktpos>maxpos then maxpos=aktpos
if aktpos<anzcube then begin
repeat;
if cubepos>anzcube then begin
if cubepos>anzcube then begin
cubepos=1
Countliste[aktpos]:=cubepos
aktpos=aktpos+1
if aktpos>maxpos then maxpos=aktpos
end;
if Countliste[aktpos]=0 then begin
//Neue Zählung
if Alwaysspacemaxreached=true then ende=true
// Wenn alle Cubes dieses Durchlaufs z.B. 8
Cubes das Speichermax überschritten haben
hat es keinen Sinn auch noch 9 Cubes zu
kontrollieren.
Alwaysspacemaxreached=true
cubepos=1
Countliste[aktpos]=Cubepos
end else begin
//Springe auf gespeicherte Position
Countliste[aktpos]= Countliste[aktpos]+1
Cubepos=Countliste[aktpos]
end
until (Cubepos<=anzcube);
if (Cubepos<>anzcube) then begin
//Setze den Zähler ganz links auf 0
- 149 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Cubepos=1
aktpos:=0
Countliste[aktpos]=Cubepos
end //Ende if (cubepos<>anzcube)
end //Ende if aktpos<anzcube
else begin
ende=true
end
{Ende 2.1.1 Wenn in der aktuellen Cursorposition das
Maximum erreicht ist}
end
// Ende von if (Cubepos>anzcube)
else
begin // Beginn von if (Cubepos>anzcube)=false
{2.1.2 Wenn in der aktuellen Cursorposition das Maximum
nicht erreicht}
aktpos=0;
istok=true
//Feststellen,ob jedes Element in der Folge nur
einmal vorkommt
for zahler:=0 to maxpos do begin
//Es wird von der Position bis zum Ende
kontrolliert da die ersten Positionen schon
verglichen wurden
for zahler2:=zahler to maxpos do begin
if ((zahler2<>zahler)and
(Countliste[zahler2]=Countliste[zahler]))
then
istok=false
end // von for zahler2
end // von for zahler
if istok=true then begin
- 150 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Spaceleft=spaceleft(Countliste)
//Feststellen des Speicherplatzes nach der
Materialisierung vom Countliste
Spaceleftfirstcubes=
spaceleft(Countliste[0..maxpos-1])
//Berechnen von spacemax von allen Würfeln
ausser dem aktuellen Würfel. Das heißt bei
z.B. 8 Cubes wird nur der spaceleft von
Cube 1 bis 7 berechnet
if Spaceleftfirstcubes<0 then begin
//Ist der Speicherplatz der Sequenz von z.B.
Cube 1 bis 7 erschöpft, macht es keinen
Sinn alle 8 Cubes durchzukontrollieren.
if aktpos=0 then begin
Countliste[0]=anzcube-1
end
end
If (spaceleft>0) then begin
Alwaysspacemaxreached=false
kostenmerk=
KostenfuerSetberechnen(Countliste)
if (kostenmerk>0) then begin
if (kostenmerk<Mincosts) or (Mincosts=0)
then begin
Mincosts=kostenmerk /Merke die
minimalen Kosten
MinCountliste=Countliste //Merke die
Teilmenge
Spaceleft=spaceleft(Countliste)
//Merke den Speicherplatz, welcher
nach der Materialisierung der
Countliste bleibt
timeleft=timeleft(Countliste)
//Merke die Zeit, welche nach dem
Materialisieren der Countliste noch
bleibt.
End //Ende von (kostenmerk<Mincosts) or
(Mincosts=0)
End //Ende von if (kostenmerk>0)
- 151 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
End//Ende von If (spaceleft>0)
end //Ende von istok
Cubepos=Cubepos+1
Countliste[aktpos]=Cubepos
{Ende 2.1.2 Wenn in der aktuellen Cursorposition das
Maximum nicht erreicht ist}
end //Ende von if (Cubepos>anzcube)=false
until (Cubepos>anzcube)
{Ende 2.1. Ende der Unterpermutationsschleife für den
letzten Zähler}
End;
{Ende 2. Beginn der Permutationsschleife}
End //von if (anzcube>0)
7.7.3 DER ALGORITHMUS FÜR DIE KOMBINATION
{1. Vorbereitungen für die Kombination}
Erzeuge Menge R der Required Cubes
Erzeuge Menge P der Possible Cubes, welche die Menge der
nicht redundanten Würfel umfasst und gib jedem Würfel einen
Nummer.
Erzeuge Countliste (array of longint) als die Teilmenge der
Menge P mit den Nummern der Possible Cubes.
Mincosts=0
anzcube=count(P) //Gibt die Anzahl der Elemente in der
Menge P der Possible Cubes an.
- 152 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
{Ende 1. Vorbereitungen für die Kombination}
{2. Algorithmus für die Kombination}
lang=0 //gibt den aktuellen Wert für k (Anzahl der
Kombinationen an – lang=k-1)
Countliste[0]=1; //Startwert für die Kombination ist der
Cube 1
Ende=false; //Abbruchwert
{2.2. Laufe durch die Kombination bis ende=true}
repeat;
alwaysspacemaxreached:=true;
//Wenn alle Kombinationen von z.B. 7 Cubes das
Speicherlimit überschreiten, wird auch eine
Kombination von 8 Cubes den Speicherwert jedenfalls
überschreiten. Darum Abbruch bei
alwaysspacemaxreached.
aktpos=0 //Gibt den Cursor auf das erste Element der
Countliste
istok=true
{2.2.1 Durchlaufe alle Kombinationen mit dem aktuellen
lang Wert}
repeat //(neuespalte=true)or(ende=true)
neuespalte=false
{2.2.1.1 Istok=true}
if (istok=true) then begin
Spaceleft=spaceleft(Countliste)
//Feststellen des Speicherplatzes nach der
Materialisierung vom Countliste
Spaceleftfirstcubes=
spaceleft(Countliste[0..maxpos-1])
//Berechnen von spacemax von allen Würfeln
ausser dem aktuellen Würfel. Das heißt bei
z.B. 8 Cubes wird nur der spaceleft von
Cube 1 bis 7 berechnet
- 153 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if Spaceleftfirstcubes<0 then begin
//Ist der Speicherplatz der Sequenz von z.B.
Cube 1 bis 7 erschöpft, macht es keinen
Sinn alle 8 Cubes durchzukontrollieren.
if aktpos=0 then
Countliste[aktpos]=anzcube
end
If (spaceleft>0) then begin
Alwaysspacemaxreached=false
Getrightorder(Countliste)
//Stelle die kostenminimale Reihenfolge
der Cubes mit einem abwandelten
Algorithmus von Dijkstra her
kostenmerk=
KostenfuerSetberechnen(Countliste)
if (kostenmerk>0) then begin
if (kostenmerk<Mincosts) or (Mincosts=0)
then begin
Mincosts=kostenmerk /Merke die
minimalen Kosten
MinCountliste=Countliste //Merke die
Teilmenge
Spaceleft=spaceleft(Countliste)
//Merke den Speicherplatz, welcher
nach der Materialisierung der
Countliste bleibt
timeleft=timeleft(Countliste)
//Merke die Zeit, welche nach dem
Materialisieren der Countliste noch
bleibt
End //Ende von (kostenmerk<Mincosts) or
(Mincosts=0)
End //Ende von if (kostenmerk>0)
End//Ende von If (spaceleft>0)
End //Ende von if (istok=true)
{Ende 2.2.1.1 Istok=true}
{2.2.1.2. Ist in der aktuellen Position (aktpos) das
Maximum erreicht oder nicht}
- 154 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if countliste[aktpos]>=(anzcube-aktpos) then
begin
{2.2.1.2.1 Setze alle cubes vom aktpos und kleiner auf 1}
Countliste[aktpos]=1
x=aktpos
repeat
Countliste[x]=1
x=x-1;
until x=-1
{Ende 2.2.1.2.1 Setze alle cubes vom aktpos und kleiner auf
1}
aktpos=aktpos+1
if countliste[aktpos]=0 then
neuespalte=true
Countliste[aktpos]:=countliste[aktpos]+1
{2.2.1.2.2. Finde den nächsten Cube, welcher nicht das
Maximum hat}
repeat;
if Countliste[aktpos]>(anzcube-aktpos)
then begin
aktpos=aktpos+1
if (aktpos>anzcube) then begin
aktpos=anzcube
ende=true
end
if Countliste[aktpos]=0 then
neuespalte=true
Countliste[aktpos]=
Countliste[aktpos]+1
end
until (Countliste[aktpos]<=(anzcubeaktpos))or(ende=true);
{Ende 2.2.1.2.2. Finde den nächsten Cube, welcher nicht das
Maximum hat}
{2.2.1.2.3.Feststellen, ob alle links richtig sind
- 155 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
x=aktpos-1
istok=true
repeat
if x>=0 then begin
Countliste[x]=Countliste[x+1]+1
end
x=x-1
until x<0;
{Ende 2.2.1.2.3.Feststellen, ob alle links richtig sind
aktpos=0
End //Ende von if countliste[aktpos]>=(anzcubeaktpos)
else begin
Countliste[aktpos]=countliste[aktpos]+1
aktpos=0
end
{Ende 2.2.1.2. Ist in der aktuellen Position (aktpos) das
Maximum erreicht oder nicht}
until (neuespalte=true)or(ende=true)
{Ende 2.2.1. Durchlaufe alle Kombinationen mit dem
aktuellen lang Wert}
if alwaysspacemaxreached=true then ende=true
lang=lang+1
until (ende=true)or(lang>anzcube)
{Ende 2.2. Laufe durch die Kombination bis ende=true}
7.7.4 DER ALGORITHMUS DER FUNKTION GETRIGHTORDER
Cost x =
∑ max{0, [getbuild (min(P(z ), z ) − getbuild (x, z ))]}
z∈A ( x )
Empfange Parameter Listecubes als Menge der zu
materialisierten und zu ordnenden Cubes
- 156 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Definiere die Knoten mittels
Knotendeklationszeiger= ^Knotendeklaration als Zeiger
auf ein Record
Knotendeklaration =
record
Knoten:longint;
spalte:longint;
zeile:longint;
MaxAbstand:Extended;
Parent:longint;
end;
Definiere Randknoten als Menge von Knoten
Definiere Innere_Knoten als Menge von Knoten
{1. Erzeuge die Menge der Randknoten und berechne die
Kosten}
for zahler:=0 to Listecubes.Count-1 do begin
//Die Cubes können nur aus dem BFT erzeugt werden
Kostengewinn:=0;
for zahler2:=0 to Listecubes.count-1 do begin
if (isderivat(Listecubes[zahler].spalte,
Listecubes[zahler].zeile,
Listecubes[zahler2].spalte,
Listecubes[zahler2].zeile)=true) then begin
//Der Kostengewinn ergibt sich daraus,
dass sich die Derivative zahler2 in
Zukunft aus dem Cube zahler ableiten
lässen.
Kostengewinn=Kostengewinn+
(//Da noch kein Würfel materialisiert
wurde, werden alle vom BFT erzeugt
max(0,getbuild(-1,-1,
Listecubes[zahler2].spalte,
Listecubes[zahler2].zeile))getbuild(Listecubes[zahler].spalte,
Listecubes[zahler].zeile),
Listecubes[zahler2].spalte,
Listecubes[zahler2].zeile)))
- 157 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end; //isderivat(…
end // von zahler2
//Erzeugen und Speichern des Cube
New(Knoten)
Knoten^.Knoten=zahler;
Knoten^.MaxAbstand=Kostengewinn;
Knoten^.Parent=-1;
Knoten^.spalte= Listecubes[zahler].spalte
Knoten^.zeile= Listecubes[zahler].zeile
Randknoten.Add(Knoten);
end;
{Ende 1. Erzeuge die Menge der Randknoten und berechne die
Kosten}
{2. Durchlaufen der Randknoten bis die Menge der Randknoten
leer ist und alle Knoten in der Menge der Innere_Knoten
sind.}
repeat
{ 2.1.Feststellen des neuen Randknotens mit dem minmalen
Abstand und Überstellen dieses Knotens von den Randknoten
zu den Inneren Knoten}
zahlermerk:=-1;costmerk:=0;
for zahler=0 to Randknoten.Count-1 do begin
Knoten= Randknoten.Items[zahler]
if (Knoten^.MaxAbstand>costmerk) or(zahlermerk=-1) then
begin
zahlermerk=zahler
costmerk:=Knoten^.MaxAbstand;
end;
end;
//Zusetzen des Würfels zu Inneren Knoten
- 158 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Knotenmerk=Randknoten.Items[zahlermerk];
Innere_Knoten.Add(Knotenmerk);
Randknoten.Delete(zahlermerk);
{Ende 2.1.Feststellen des neuen Randknotens und Überstellen
dieses Knotens von den Randknoten zu den Inneren Knoten}
if Randknoten.Count>0 then begin
{2.2. Durchlaufe die aktuelle Menge der Randknoten}
for zahler=0 to Randknoten.count-1 do begin
Knoten= Randknoten.items[zahler];
{2.2.1 Stelle fest, ob die Randknoten Derivative von dem
neuen Inneren Knoten sind. Wenn ja und die Kosten sind
geringer als die vom BFT, dann ändere Kosten. Ist jedoch
der neue Innere Cube ein Derivative von dem Randknoten,
müssen die Kosten neu berechnet werden.}
if
(isderivat(Knotenmerk^.spalte,Knotenmerk^.zeile,
Knoten^.spalte,Knoten^.zeile)=true) or
(isderivat(Knoten^.spalte,Knoten^.zeile,
Knotenmerk^.spalte,Knotenmerk^.zeile)=true)
then begin
{2.2.1.1 Durchlaufe alle Randknoten und suche Parent}
Kostengewinn:=0;
for zahler2:=0 to Randknoten.Count-1 do begin
Knoten2:=Randknoten.Items[zahler2]
//Stelle fest, ob dieser Randknoten ein Derivat ist
if (isderivat(Knoten^.spalte,Knoten^.zeile,
Knoten2^.spalte,Knoten2.zeile)=true)
and(Knoten^.Knoten<>Knoten2^.Knoten) then begin
//Finde das Kostenminimale Parent von Knoten2
Parentvonderivat=-1
Parentvonderivatcostmerk:=getbuild(-1,-1,
Knoten2.spalte,Knoten2^.zeile)
for zahler3:=0 to Innere_Knoten.count-1 do begin
- 159 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Knoten3:=Innere_Knoten.Items[zahler3]
if (isderivat(Knoten3^.spalte,Knoten3^.zeile,
Knoten2^.spalte,Knoten2^.zeile)=true)and
(Knoten3^.Knoten<>Knotenmerk^.Knoten)and
(Knoten3^.Knoten<>Knotenmerk^.Knoten)then begin
costmerk:=getbuild(Knoten3^.spalte,
Knoten3^.zeile, Knoten2^.spalte,
Knoten2^.zeile)
if (costmerk<Parentvonderivatcostmerk) then
begin
Parentvonderivat=zahler3
Parentvonderivatcostmerk=costmerk
end //von costmerk<parentvorderivatcostmerk
end //isderivat
end //von Zahler3
if parentvonderivat<>-1 then begin
Knoten3:=Innere_Knoten.Items[parentvonderivat]
Kostengewinn:=Kostengewinn+max(0,((
getbuild(Knoten3^.spalte, Knoten3^.zeile,
Knoten2^.spalte, Knoten2^.zeile) getbuild(Knoten^.spalte, Knoten^.zeile,
Knoten2^.spalte, Knoten2^.zeile))))
end else begin
Kostengewinn:=Kostengewinn+max(0,((getbuild(-1,1, Knoten2^.spalte, Knoten2^.zeile)getbuild(Knoten^.spalte, Knoten^.zeile,
Knoten2^.spalte, Knoten2^.zeile))))
end;
end;//End von isderivative
end //zahler2
{Ende 2.2.1.1 Durchlaufe alle Randknoten und suche Parent}
end //isdervative
{Ende 2.2.1 Stelle fest, ob die Randknoten Derivative von
dem neuen Inneren Knoten sind. Wenn ja und die Kosten sind
geringer als die vom BFT, dann ändere Kosten. Ist jedoch
- 160 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
der neue Innere Cube ein Derivative von dem Randknoten,
müssen die Kosten neu berechnet werden}
end //zahler
{Ende 2.2. Durchlaufe die aktuelle Menge der Randknoten}
end // Ende von Randknoten.count>0
until Randknoten.Count=0
{Ende 2. Durchlaufen der Randknoten bis die Menge der
Randknoten leer ist und alle Knoten in der Menge der
Innere_Knoten sind.}
{3. Übergebe die Sequenz der Inneren Randknoten}
Result:=Innere_Randknoten
{Ende 3. Übergebe die Sequenz der Inneren Randknoten}
7.7.5 DER ALGORITHMUS DER FUNKTION
KOSTENFUERSETBERECHNEN
Diese Funktion berechnet die Kosten eines an die Funktion übergebenen Menge von
Materialisierten Würfel und einer an die Funktion übergebenen Menge von Required
Cubes. Dabei werden die Materialisierungs- und die Abfragekosten berechnet und
zurückgegeben. Wird das Zeitlimit der Materialisierung überschritten, wird als Wert 0
zurückgeben.
Empfange Parameter MatCubes als Menge der zu
materialiserten Cubes
Empfange Parameter ReqCubes als Menge der required Cubes
{1. Feststellen, ob die Cubes die Spacemaxbedingung
erfüllen}
spaceleft=calculatespacemaxof(Countliste)
timeleft=Maxavailabletime
{Ende 1. Feststellen, ob die Cubes die Spacemaxbedingung
erfüllen}
- 161 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if spaceleft>0 then begin
{2. Kosten berechnen}
SummeKosten=0
{2.1 Ersten Cube zusetzen}
aktspalte=MemoryCubes[Countliste[0]].spalte
//Spaltenwert des ersten Cubes
aktzeile=MemoryCubes[Countliste[0]].zeile
//Zeilenwert des ersten Cubes
newcosts=getbuild(-1,-1,aktspalte,aktzeile)
//Der erste Cube wird aus dem BFT (-1,-1) erzeugt.
Deshalb sind die newcosts gleich den
Materialisierungskosten aus dem BFT
SummeKosten=SummeKosten+newcosts
Memorywuerfel.Add(aktspalte,aktzeile)
timemax=timemax-newcosts //Vermindere Timemax um die
Materialisierungszeit des ersten Cube
{Ende 2.1 Ersten Cube zusetzen}
{2.2 Weitere Cubes zusetzen}
for x= 1 to Maxpos do begin
aktspalte:=MemoryCubes[Countliste[x]].spalte;
aktzeile:=MemoryCubes[Countliste[x]].zeile;
{2.2.1 Kann der Cube aus einem bereits materialisierten
Cube abgeleitet werden}
if isderivatof(Memorywuerfel)=true then begin
newminderivatspalte:=GetMinDerivatOfSpalte(aktspa
lte,aktzeile)
newminderivatzeile:=GetMinDerivatOfZeile(aktspalt
e,
aktzeile)
newcosts=getbuild(newminderivatspalte,
newminderivatzeile,aktspalte,aktzeile);
SummeKosten=SummeKosten+newcosts
Memorywuerfel.Add(aktspalte,aktzeile);
timemax:=timemax-newcosts
- 162 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end
{Ende 2.2.1 Kann der Cube aus einem bereits
materialisierten Cube abgeleitet werden}
{2.2.2 Der Cube kann nicht aus einem bereits
materialisierten Cube abgeleitet werden}
else begin
newcosts=getbuild(-1,-1,aktspalte,aktzeile)
SummeKosten=SummeKosten+newcosts
Memorywuerfel.Add(aktspalte,aktzeile);
timemax:=timemax-newcosts
end
{Ende 2.2.2 Der Cube kann nicht aus einem bereits
materialisierten Cube abgeleitet werden}
end //Ende von for x=1 …
{Ende 2.2 Weitere Cubes zusetzen}
{2.3 Berechnen der Kosten für die Abfragen aller Required
Cubes}
for zahler=0 to MemoryReqCubescount.count-1 do begin
spalte=MemoryReqCubes[zahler].spalte
zeile=MemoryReqCubes[zahler].zeile
{2.3.1. Wenn der Cube aus den materialisierten Cubes
abgefragt werden kann}
if isderivatof(Memorywuerfel)=true then begin
newminderivatspalte=
GetMinDerivatOfSpalte(spalte,zeile)
newminderivatzeile= GetMinDerivatOfZeile(spalte,zeile)
newcosts= ((getquery( newminderivatspalte,
newminderivatzeile, spalte, zeile))
*APA[spalte,zeile].gewicht);//Häufigkeit der Abfrage
(globale Variable APA)
SummeKosten=SummeKosten+newcosts
end
{Ende 2.3.1. Wenn der Cube aus den materialisierten Cubes
abgefragt werden kann}
{2.3.2. Wenn der Cube nur aus dem BFT abgefragt werden
kann}
- 163 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
else begin
newcosts=((getquery(-1,-1,spalte,zeile))
*APA[spalte,zeile].gewicht) //Häufigkeit der
Abfrage (globale Variable APA)
SummeKosten=SummeKosten+newcosts
End
{Ende 2.3.2. Wenn der Cube nur aus dem BFT abgefragt werden
kann}
end;
{Ende 2.3 Berechnen der Kosten für die Abfragen aller
Required Cubes}
{Ende 2. Kosten berechnen}
if (timemax<0) then begin;
Summekosten=0
end
end //Ende von spacemax>0
{3. Übergeben der Kosten}
Result=SummeKosten
Spaceleft=spacemax //Globale Variable spaceleft
Timeleft=timemax //Globale Variable timeleft
{Ende 3. Übergeben der Kosten}
7.8 DIE ENTWICKLUNGSUMGEBUNG UND DIE APPLIKATION
7.8.1 AUSWAHL DER ENTWICKLUNGSUMGEBUNG
Die Auswahl der Entwicklungsumgebung ging mit der Auswahl des Betriebssystems
analog. Das Ziel war natürlich eine Anwendung zu gestalten, welche auf möglichst
vielen Betriebssystemen lauffähig ist. Die Hauptanwenderzielgruppe sind die Studenten
der Wirtschaftsuniversität Wien, welche die Anwendung in den Seminaren als
Fortbildungsinstrument nutzen sollen. Da die Rechner der Wirtschaftsuniversität auf
Windows laufen wurde somit ein Windowslauffähiges Programm als
Mindestanforderung an die Programmierumgebung definiert. Schließlich fiel die
- 164 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Entscheidung auf eine im Besitz des Autors befindliche Version vom Borland Delphi
(siehe auch www.borland.com) Version 7.0 for .NET. Dieser Softwarecompilier
produziert sowohl Windows lauffähige Version, als auch, über Kylix compiliert, eine
Linux lauffähige Version des Programms. Zusätzlich steht die Produktion der .NET
fähigen Delphi Version Octane unmittelbar bevor. Dann wäre eine Compilierung auf
.NET möglich.
In den ersten Versionen des Programms wurde zusätzlich eine Datenbank integriert.
Allerdings ist eine Installation eines Programms mit einem Datenbanktreiber auf den
Rechner der Universität nur mit Administratorrechten möglich. Deshalb wurde die
Datenbank wieder entfernt und auf eine Speicherung der Daten in einfachen Datenfiles
mit eigener Indexprogrammierung ausgewichen.
7.8.2 ENTWURF DER BENUTZERSCHNITTSTELLE
Die Benutzerschnittstelle der Software soll in übersichtlicher Weise dem Benutzer –
zumeist Studenten – die Möglichkeit bieten, das System des APA zu verstehen und ein
Datawarehouse zu modellieren. Ich will dabei die wichtigsten modularen Schnittstellen
kurz vorstellen.
7.8.2.1
DAS HAUPTMENU
Das Hauptmenü des APA Programmes ist übersichtlich gestaltet. Die wichtigsten
Unterscreens des Programmes, der Input Screen, der APA Grid Screen und APA
Selection Screen werden entsprechend der logischen Abfolge im Zentrum angeordenet.
Zusätzlich gibt das Hauptmenü unter dem Punkt File die Möglichkeit APAs zu laden
und zu speichern. Unter dem Menupunkt Screens können alle Screens separat
aufgerufen werden. Der Punkt Berechnung ermöglicht das Erstellen der Zufallskosten
und einige Analysetools für das APA Grid. Im Unterpunkt Settings ist es möglich, die
Optionen für das Programm und die Parameter für die Heuristik bzw. die
deterministische Lösung einzustellen. Im Menüpunkt Help findet man eine ausführliche
Dokumentation des Software Tools, welches unerfahrenen Benutzern beim Einstieg in
die Software begleiten soll.
- 165 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 69: Das Hauptmenu des APA Programmes
7.8.2.2
DIE EINGABEMASKE (INPUT SCREEN)
Die Eingabemaske ermöglicht dem Benutzer das Eingeben und Ordnen der Dimension
und Hierarchien. Zusätzlich werden die Key Figures eingegeben, welche für das
Generieren der SQL Statements benötigt werden. Die Hierarchien werden mit der
Anzahl ihrer Ausprägungen gespeichert. Dadurch können im Hintergrund
Berechnungen über Tupelanzahl der einzelnen Tabellen durchgeführt werden.
- 166 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 70: Der APA Input Screen
7.8.2.3
DIE PRÄSENTATIONSMASKE (APA SCREEN)
Die Präsentationsmaske des APA Grid ist das umfangreichste Modul im Programm. Es
erlaubt dem Benutzer nicht nur das Betrachten und Analysieren des APA, sondern auch
Ausführen einer Reihe von Analysetools und Anzeigen von Hintergrundinformation.
Dabei können die Funktionen über das Hauptmenü oder für zellenbasierende
Funktionen über das Popup Menu aufgerufen werden. Zusätzlich sind Buttons für
häufige Funktionen unter dem Hauptmenü angeordnet.
- 167 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 71: Die Präsentationsmaske des APA Grid
7.8.2.4
DIE AUSWAHLMASKE DER REQUIRED CUBES (SELECTION
SCREEN)
Der APA Selection Screen soll den Benutzer unterstützen, die „Required Cubes“ im
APA, welche für ihn interessant sind, zu finden. Dies ist besonders bei großen APAs
mit zahlreichen Dimensionen und Hierarchiestufen von Bedeutung, da die
Übersichtlichkeit durch Benutzen des APA Selection Screen bestehen bleibt. Zusätzlich
können Roll Ups oder Drill Down über Dimensionen durchgeführt werden und in einem
Eingabeschritt markiert werden.
- 168 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 72: Die Auswahlmaske der Required Cubes
7.8.3 DATENMODELLIERUNG DER APPLIKATION
7.8.3.1
AUSWAHL DER DATENBANK
Die Auswahl der Hauptdatenbank für die Applikation wurde auf den Vorschlag von
Prof. Prosser mit Microsoft SQL fixiert. Das Ziel ist es nicht nur die Eingaben in die
APA Software speichern zu können, sondern auch die CREATE TABLE Anweisungen
für die BFT und Zusatztabellen (bei Fact Constellation Schema) zu generieren.
Zusätzlich war mein Ansinnen jedoch, die Daten der Applikation für weitere
Datenbanken (MySql, Paradox) und sogar als Textfile sichern zu können. Dies ist
besonders für die weltweite Benutzung essentiell. Die Endversion des Programms
wurde aber ohne eine Datenbankanbindung produziert, da die Installation der
Datenbank auf der Universität nicht ohne Administratorrechte durchgeführt werden
kann und das Ziel eine universell einsetzbare Anwendung im Vordergrund stand.
Trotzdem sollte eine Endbenutzerversion des Programms mit eine leistungsfähigen
Datenbank kombiniert werden. Dies ist besonders im vernetzten betrieblichen Einsatz
notwendig, wo für den einzelnen Benutzer unterschiedliche Benutzerrechte gelten.
- 169 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.8.3.2
SEMANTISCHE DATENMODELLIERUNG
Die Semantische Datenmodellierung beschreibt die Daten als ER Diagramm. Das
folgende ER-Diagramm soll die Grundlage der Daten in einer MS SQL Datenbank
darstellen. Diese Datenbanken werden jedoch nicht von der im Anhang beschriebenen
Software real verwendet, da diese im Lehrbetrieb auf der Wirtschaftsuniversität
verwendet werden soll und das Anlegen von Benutzerrechten für jeden Studenten eine
große administrative Aufgabenstellungen bedeuten würde. Allerdings will ich
exemplarisch diese Variante durchdiskutieren. Sollte jedoch diese Software jemals zu
einem Endanwenderprodukt für den Verkauf aufgewertet werden, bildete diese
Datenmodellierung die Grundlage und gibt zusätzlich ein gutes demonstratives Beispiel
für die klassische Datenmodellierung.
- 170 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 73: ER-Diagramm für die APA Datenbank
Das ER-Diagramm besteht aus einer Reihe von Entitäten und Beziehungen. Aus
Gründen der besseren Übersicht und klaren Lesbarkeit wurden die Attribute in dieser
Darstellung entfernt.
Die Entität „Administrator“ steht mit der Entität „Benutzer“ in einer m:n Beziehung. Es
soll ein Systemadministrator mehrere Benutzer bearbeiten können und ein Benutzer soll
von mehreren Systemadministratoren bearbeitet werden können.
Die Entität „Benutzer“ besitzt mehrere „Gitter“. Ein Benutzer kann also mehrere Data
Warehouse Modelle parallel bearbeiten. Ein „Gitter“ wird aber immer nur einem
Benutzer zugeordnet.
- 171 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Das „Gitter“ enthält oder besteht aus vielen „Zellen“. Diese Zellen kann man sich
ähnlich einer Zelle in einem Tabellenkalkulationsprogramm vorstellen. Die Entität
„Zelle“ repräsentiert aber wiederum einen speziellen „Würfel“ (Cube) im
multidimensionalen Data Warehouse. Wobei jede „Zelle“ immer nur einen „Würfel“
repräsentieren kann.
Ein „Würfel“ hat wiederum spezifische Eigenschaften, die ihn beschreiben. Er besteht
aus einer Reihe von Dimensionen, die wiederum eine bestimmte Hierarchiestufe haben.
Dies wird mit der „virtuellen“ Entität „Dimension auf einer Hierarchiestufe“
ausgedrückt. Ein „Würfel“ kann sich aus mehreren Dimensionen mit einer bestimmten
Hierarchiestufe zusammensetzen. Eine Dimension kann aber nur einmal in einem
Würfel vorkommen. Deshalb ist die Beziehung zwischen der Entität „Würfel“ und der
Entität „Dimension auf einer Hierarchiestufe“ eine 1:n Beziehung.
Das „Gitter“ wird generiert aus mehreren „Dimensionen“, die wiederum mehrere
„Hierarchiestufen“ haben können. Deshalb gibt es sowohl eine 1:n Beziehung zwischen
der Entität „Gitter“ und „Dimensionen“, als auch zwischen der Entität „Dimensionen“
und „Hierarchiestufen“.
„Dimensionen“ werden mehrmals von der Entität „Dimension auf einer
Hierarchiestufe“ verwendet. Die Entität „Dimension auf einer Hierarchiestufe“ kann
aber nur eine Dimension haben. Ähnlich die Situation auf der Seite der
Hierarchiestufen. Die Entität „Hierarchiestufe“ kann mehrmals in der Entität
„Dimension auf einer Hierarchiestufe“ verwendet werden. Die Entität „Dimension auf
einer Hierarchiestufe“ hat im Namen schon enthalten, dass die Dimension nur auf einer
Hierarchiestufe sein kann.
Zum Entwickeln der Benutzeranforderungen wurden zusätzlich noch 3 Entitäten in das
ER-Diagramm eingefügt. Die Entität „Benutzeranforderungen“ repräsentiert
unterschiedliche Benutzeranforderungen einem Gitter. Dies können Finanzkennzahlen,
Lagerstandsabfragen, kundenbezogene Kennzahlen, etc. sein. Diese kann der Benutzer
in der Entität „Benutzeranforderungen“ separat gruppieren und übersichtlich behandeln.
Natürlich soll es dem Benutzer gestattet sein mehrere Benutzeranforderungen an ein
Gitter zu stellen. Deshalb ist die Beziehung zwischen der Entität „Gitter“ und der Entität
„Benutzeranforderungen“ eine 1:n Beziehung. Diese Benutzeranforderungen werden
jedoch in mehrere Blöcke unterteilt, die wiederum aus mehreren Detailanforderungen
bestehen können. Eine beispielhafte Detailanforderung wäre „Die Kunden gruppiert
nach Bundesland“ (Das würde der Dimension „Kunden“ auf der Hierarchiestufe
„Bundesland“ entsprechen). Ein fertiger Block wäre z.B. „Alle Umsätze der Kunden pro
Bundesland (erste Detailanforderung), aller Artikeln (zweite Detailanforderung –
höchste Hierarchiestufe der Artikeln) und in der Zeitspanne pro Monat mit einem „RollUp“ bis zum Jahr (dritte Detailanforderung).
- 172 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Natürlich können nur wieder Dimensionen und Hierarchien für die Detailanforderungen
verwendet werden, die in der Entität „Dimensionen“ bzw. in der Entität
„Hierarchiestufen“ angelegt wurden. Dies wird durch die 1:n Beziehungen zwischen
„Hierarchiestufen“ und „Detailanforderungen“ und „Dimensionen“ und
„Detailanforderungen“ ausgedrückt.
7.8.3.3
LOGISCHE DATENMODELLIERUNG
Die Ableitung des APA Relationenmodells aus dem APA ER-Modells erfolgt analog
nach der oben beschriebenen Standardvorgehensweise beim Entwickeln von
relationalen Datenbanksystemen [vgl. Riordan (2000) S.149ff]. Die Entitäten wurden in
Tabellen umgesetzt. Eine zusätzliche Tabelle wurde für die Beziehung zwischen
Administratoren (APA_Admin) und Benutzern (APA_User) erzeugt. Die Umsetzung
erfolgt mit dem Microsoft SQL 2000 Server. Auf Grund der Umsetzung des ER Diagramms enthält die Datenbank folgende Tables mit Primärschlüsseln.
- 173 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Table
Beschreibung
Primärschlüssel
APA_Admin
Administratoren
AdminID
Beziehung m:n Beziehung
zwischen Administratoren
und Benutzern
AdminID
APA_Admin_User
APA_User
APA_Dimension
UserID
Benutzer und Besitzer des
UserID
Gitters
GitterID
Dimensionen des Gitters
DimensionID
APA_Hierarchy
GitterID
Hierarchien der einzelnen
DimensionID
Dimensionen eines Gitters
Hierarchylevel
APA_Gitter
Daten über das Gitter
APA_Cells
Zellen des Gitters und
deren Daten
GitterID
GitterID
Row
Column
APA_Cube
GitterID
Hierarchiestufen der
Row
einzelnen Dimensionen des
Column
Gitters
DimensionID
APA_Req
Anforderungsliste des
Benutzer für ein
bestimmtes Gitter
APA_ReqBlock
GitterID
Reqirement Block für jedes
ReqID
APA_req Objekt
BlockID
GitterID
ReqID
GitterID
APA_Detailreq
Detailanforderungen jedes ReqID
Blocks
BlockID
DetailreqID
Tabelle 10: : Beschreibung der Tables der APA Datenbank
- 174 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 74: Ableitung des APA Relationenmodells aus dem APA ER-Modell
- 175 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.8.3.4
PHYSISCHE DATENMODELLIERUNG
Das physische Datenmodell beschreibt die Daten des Informationssystems auf der
Ebene der technischen Implementierung. Das physische Datenmodell bezieht sich auf
ein konkretes Datenbankprodukt. Im Zuge dieser Arbeit wird Microsoft SQL 2000
Server als Datenbankprodukt fixiert. Im folgenden werde ich deshalb auf die konkreten
physischen Ausprägungen im Sinne der „CREATE TABLE“ Anweisungen eingehen,
welche auf den Notationen von Barth (2002) S. 127ff und Taylor (2001) S. 41 ff
basieren.
7.8.3.4.1
FORMALE SQL-ANWEISUNGEN LAUT SQL 99
CREATE TABLE APA_Admin (
AdminID INTEGER NOT NULL ,
Admindescription VARCHAR(25) NOT NULL ,
PRIMARY KEY (AdminID)
);
CREATE TABLE APA_Admin_User (
AdminID INTEGER NOT NULL ,
UserID INTEGER NOT NULL,
PRIMARY KEY (AdminID, UserID)
);
CREATE TABLE APA_Cells (
GitterID INTEGER NOT NULL ,
Row INTEGER NOT NULL ,
Column INTEGER NOT NULL ,
Short_Description VARCHAR(8) NOT NULL ,
Caption VARCHAR(8) NOT NULL ,
DimensionID INTEGER NOT NULL ,
HierarchyID INTEGER NOT NULL ,
Interesting BIT NOT NULL ,
Materialized BIT NOT NULL ,
Derivative BIT NOT NULL ,
Linetop BIT NOT NULL ,
Linebottom BIT NOT NULL ,
Lineleft BIT NOT NULL ,
Lineright BIT NOT NULL ,
Boldtop BIT NOT NULL ,
Boldbottom BIT NOT NULL ,
Boldleft BIT NOT NULL ,
Boldright BIT NOT NULL,
PRIMARY KEY (GitterID)
);
CREATE TABLE APA_Cube (
- 176 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
GitterID INTEGER NOT NULL ,
Row INTEGER NOT NULL ,
Column INTEGER NOT NULL ,
DimensionID INTEGER NOT NULL ,
Hierarchylevel INTEGER NOT NULL,
PRIMARY KEY (GitterID, Row, Column, DimensionID)
);
CREATE TABLE APA_Detailreq (
GitterID INTEGER NOT NULL ,
ReqID INTEGER NOT NULL ,
BlockID INTEGER NOT NULL ,
DetailReqID INTEGER NOT NULL ,
DimensionID INTEGER NOT NULL ,
Hierarchylevel INTEGER NOT NULL ,
Methode VARCHAR(10),
EndHierarchylevel INTEGER NULL,
PRIMARY KEY (GitterID, RegID, BlockID, DetailreqID)
);
CREATE TABLE APA_Dimension (
GitterID INTEGER NOT NULL ,
DimensionID INTEGER NOT NULL ,
Dimension_Description VARCHAR(40),
PRIMARY KEY (GitterID, DimensionID)
);
CREATE TABLE APA_Gitter (
GitterID INTEGER IDENTITY (1, 1) NOT NULL ,
Description VARCHAR(40) NOT NULL ,
UserID INTEGER NOT NULL ,
Rowcount INTEGER NOT NULL ,
Columncount INTEGER NOT NULL,
PRIMARY KEY (GitterID)
);
CREATE TABLE APA_Hierarchy (
GitterID INTEGER NOT NULL ,
DimensionID INTEGER NOT NULL ,
Hierarchylevel INTEGER NOT NULL ,
Short_Description VARCHAR(8) NOT NULL ,
Long_Description] VARCHAR(50),
PRIMARY KEY (GitterID, DimensionID, Hierarchielevel)
);
CREATE TABLE APA_Req (
GitterID INTEGER NOT NULL ,
ReqID INTEGER IDENTITY (1, 1) NOT NULL ,
ReqDecription VARCHAR(30),
- 177 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
PRIMARY KEY (GitterID, RegID)
);
CREATE TABLE APA_ReqBlock (
GitterID INTEGER NOT NULL ,
ReqID INTEGER NOT NULL ,
BlockID INTEGER IDENTITY (1, 1) NOT NULL ,
Description VARCHAR (30),
PRIMARY KEY (GitterID, ReqID, BlockID)
);
CREATE TABLE APA_User (
UserID INTEGER IDENTITY (1, 1) NOT NULL ,
Description VARCHAR(50) NOT NULL ,
Password VARCHAR(15) NOT NULL,
PRIMARY KEY (UserID)
);
7.8.3.4.2
MICROSOFT SQL SPEZIFISCHE SQL ANWEISUNGEN
Jeder Datenbankhersteller unterstützt zwar SQL als Standard, verwendet aber leider oft
eigene Dialekte und Formatsyntax für seine Datenbankprodukte. Um dem Rechnung zu
tragen, dass meine Anwendung auf Microsoft SQL als Datenbank abzielt, will ich hier
die spezifischen SQL Anweisungen, die auf Grund der in Abbildung 36 dargestellten
relationalen Struktur entwickelt wurden, hier anführen. Zusätzlich zu den „CREATE
TABLE“ Anweisungen werden im Script auch am Beginn überprüft, ob die Tabellen
vorhanden sind (if exists) und gegebenenfalls gelöscht.
Überprüfungen:
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[FK_APA_Admin_User_APA_Admin]') and
OBJECTPROPERTY(id, N'IsForeignKey') = 1)
ALTER TABLE [dbo].[APA_Admin_User] DROP CONSTRAINT
FK_APA_Admin_User_APA_Admin
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[FK_APA_Cube_APA_Cells]') and
OBJECTPROPERTY(id, N'IsForeignKey') = 1)
ALTER TABLE [dbo].[APA_Cube] DROP CONSTRAINT
FK_APA_Cube_APA_Cells
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[FK_APA_Cube_APA_Dimension]') and
OBJECTPROPERTY(id, N'IsForeignKey') = 1)
- 178 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
ALTER TABLE [dbo].[APA_Cube] DROP CONSTRAINT
FK_APA_Cube_APA_Dimension
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[FK_APA_Detailreq_APA_Dimension]') and
OBJECTPROPERTY(id, N'IsForeignKey') = 1)
ALTER TABLE [dbo].[APA_Detailreq] DROP CONSTRAINT
FK_APA_Detailreq_APA_Dimension
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[FK_APA_Hierarchy_APA_Dimension1]') and
OBJECTPROPERTY(id, N'IsForeignKey') = 1)
ALTER TABLE [dbo].[APA_Hierarchy] DROP CONSTRAINT
FK_APA_Hierarchy_APA_Dimension1
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[FK_APA_Cells_APA_Gitter]') and
OBJECTPROPERTY(id, N'IsForeignKey') = 1)
ALTER TABLE [dbo].[APA_Cells] DROP CONSTRAINT
FK_APA_Cells_APA_Gitter
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[FK_APA_Dimension_APA_Gitter]') and
OBJECTPROPERTY(id, N'IsForeignKey') = 1)
ALTER TABLE [dbo].[APA_Dimension] DROP CONSTRAINT
FK_APA_Dimension_APA_Gitter
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[FK_APA_Req_APA_Gitter]') and
OBJECTPROPERTY(id, N'IsForeignKey') = 1)
ALTER TABLE [dbo].[APA_Req] DROP CONSTRAINT
FK_APA_Req_APA_Gitter
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[FK_APA_Cube_APA_Hierarchy]') and
OBJECTPROPERTY(id, N'IsForeignKey') = 1)
ALTER TABLE [dbo].[APA_Cube] DROP CONSTRAINT
FK_APA_Cube_APA_Hierarchy
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[FK_APA_Detailreq_APA_Hierarchy]') and
OBJECTPROPERTY(id, N'IsForeignKey') = 1)
- 179 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
ALTER TABLE [dbo].[APA_Detailreq] DROP CONSTRAINT
FK_APA_Detailreq_APA_Hierarchy
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[FK_APA_Detailreq_APA_Hierarchy1]') and
OBJECTPROPERTY(id, N'IsForeignKey') = 1)
ALTER TABLE [dbo].[APA_Detailreq] DROP CONSTRAINT
FK_APA_Detailreq_APA_Hierarchy1
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[FK_APA_ReqBlock_APA_Req]') and
OBJECTPROPERTY(id, N'IsForeignKey') = 1)
ALTER TABLE [dbo].[APA_ReqBlock] DROP CONSTRAINT
FK_APA_ReqBlock_APA_Req
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[FK_APA_Detailreq_APA_ReqBlock]') and
OBJECTPROPERTY(id, N'IsForeignKey') = 1)
ALTER TABLE [dbo].[APA_Detailreq] DROP CONSTRAINT
FK_APA_Detailreq_APA_ReqBlock
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[FK_APA_Admin_User_APA_User]') and
OBJECTPROPERTY(id, N'IsForeignKey') = 1)
ALTER TABLE [dbo].[APA_Admin_User] DROP CONSTRAINT
FK_APA_Admin_User_APA_User
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[FK_APA_Gitter_APA_User]') and
OBJECTPROPERTY(id, N'IsForeignKey') = 1)
ALTER TABLE [dbo].[APA_Gitter] DROP CONSTRAINT
FK_APA_Gitter_APA_User
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[APA_Admin]') and OBJECTPROPERTY(id,
N'IsUserTable') = 1)
drop table [dbo].[APA_Admin]
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[APA_Admin_User]') and OBJECTPROPERTY(id,
N'IsUserTable') = 1)
drop table [dbo].[APA_Admin_User]
- 180 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[APA_Cells]') and OBJECTPROPERTY(id,
N'IsUserTable') = 1)
drop table [dbo].[APA_Cells]
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[APA_Cube]') and OBJECTPROPERTY(id,
N'IsUserTable') = 1)
drop table [dbo].[APA_Cube]
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[APA_Detailreq]') and OBJECTPROPERTY(id,
N'IsUserTable') = 1)
drop table [dbo].[APA_Detailreq]
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[APA_Dimension]') and OBJECTPROPERTY(id,
N'IsUserTable') = 1)
drop table [dbo].[APA_Dimension]
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[APA_Gitter]') and OBJECTPROPERTY(id,
N'IsUserTable') = 1)
drop table [dbo].[APA_Gitter]
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[APA_Hierarchy]') and OBJECTPROPERTY(id,
N'IsUserTable') = 1)
drop table [dbo].[APA_Hierarchy]
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[APA_Req]') and OBJECTPROPERTY(id,
N'IsUserTable') = 1)
drop table [dbo].[APA_Req]
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[APA_ReqBlock]') and OBJECTPROPERTY(id,
N'IsUserTable') = 1)
drop table [dbo].[APA_ReqBlock]
GO
- 181 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[APA_User]') and OBJECTPROPERTY(id,
N'IsUserTable') = 1)
drop table [dbo].[APA_User]
GO
CREATE TABLE Anweisungen:
CREATE TABLE [dbo].[APA_Admin] (
[AdminID] [int] NOT NULL ,
[Admindescription] [char] (25) COLLATE
Latin1_General_CI_AS NOT NULL
) ON [PRIMARY]
GO
CREATE TABLE [dbo].[APA_Admin_User] (
[AdminID] [int] NOT NULL ,
[UserID] [int] NOT NULL
) ON [PRIMARY]
GO
CREATE TABLE [dbo].[APA_Cells] (
[GitterID] [int] NOT NULL ,
[Row] [int] NOT NULL ,
[Column] [int] NOT NULL ,
[Short_Description] [char] (250) COLLATE
Latin1_General_CI_AS NULL ,
[Caption] [char] (8) COLLATE Latin1_General_CI_AS NOT
NULL ,
[DimensionID] [int] NOT NULL ,
[HierarchyID] [int] NOT NULL ,
[Interesting] [bit] NOT NULL ,
[Materialized] [bit] NOT NULL ,
[Derivative] [bit] NOT NULL ,
[Linetop] [bit] NOT NULL ,
[Linebottom] [bit] NOT NULL ,
[Lineleft] [bit] NOT NULL ,
[Lineright] [bit] NOT NULL ,
[Boldtop] [bit] NOT NULL ,
[Boldbottom] [bit] NOT NULL ,
[Boldleft] [bit] NOT NULL ,
[Boldright] [bit] NOT NULL
) ON [PRIMARY]
GO
CREATE TABLE [dbo].[APA_Cube] (
[GitterID] [int] NOT NULL ,
[Row] [int] NOT NULL ,
- 182 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
[Column] [int] NOT NULL ,
[DimensionID] [int] NOT NULL ,
[Hierarchylevel] [int] NOT NULL
) ON [PRIMARY]
GO
CREATE TABLE [dbo].[APA_Detailreq] (
[GitterID] [int] NOT NULL ,
[ReqID] [int] NOT NULL ,
[BlockID] [int] NOT NULL ,
[DetailReqID] [int] NOT NULL ,
[DimensionID] [int] NOT NULL ,
[Hierarchylevel] [int] NOT NULL ,
[Methode] [char] (10) COLLATE Latin1_General_CI_AS
NULL ,
[EndHierarchylevel] [int] NULL
) ON [PRIMARY]
GO
CREATE TABLE [dbo].[APA_Dimension] (
[GitterID] [int] NOT NULL ,
[DimensionID] [int] NOT NULL ,
[Dimension_Description] [char] (40) COLLATE
Latin1_General_CI_AS NULL
) ON [PRIMARY]
GO
CREATE TABLE [dbo].[APA_Gitter] (
[GitterID] [int] IDENTITY (1, 1) NOT NULL ,
[Description] [char] (40) COLLATE Latin1_General_CI_AS
NOT NULL ,
[UserID] [int] NOT NULL ,
[Rowcount] [int] NOT NULL ,
[Columncount] [int] NOT NULL
) ON [PRIMARY]
GO
CREATE TABLE [dbo].[APA_Hierarchy] (
[GitterID] [int] NOT NULL ,
[DimensionID] [int] NOT NULL ,
[Hierarchylevel] [int] NOT NULL ,
[Short_Description] [char] (8) COLLATE
Latin1_General_CI_AS NOT NULL ,
[Long_Description] [char] (50) COLLATE
Latin1_General_CI_AS NULL
) ON [PRIMARY]
GO
CREATE TABLE [dbo].[APA_Req] (
- 183 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
[GitterID] [int] NOT NULL ,
[ReqID] [int] IDENTITY (1, 1) NOT NULL ,
[ReqDecription] [char] (30) COLLATE
Latin1_General_CI_AS NULL
) ON [PRIMARY]
GO
CREATE TABLE [dbo].[APA_ReqBlock] (
[GitterID] [int] NOT NULL ,
[ReqID] [int] NOT NULL ,
[BlockID] [int] IDENTITY (1, 1) NOT NULL ,
[Description] [char] (30) COLLATE Latin1_General_CI_AS
NULL
) ON [PRIMARY]
GO
CREATE TABLE [dbo].[APA_User] (
[UserID] [int] IDENTITY (1, 1) NOT NULL ,
[Description] [char] (50) COLLATE Latin1_General_CI_AS
NOT NULL ,
[Password] [char] (15) COLLATE Latin1_General_CI_AS
NOT NULL
) ON [PRIMARY]
GO
7.8.3.5
GENERIEREN DER CREATE TABLE ANWEISUNGEN IN DER
SOFTWARE
Unsere Software kann dem Benutzer SQL-Scripts generieren, welche dieser direkt an
einen Microsoft SQL Server schicken kann und damit die Tables, bzw. die Aggregate
erzeugt werden. Dabei wollen wir die zwei einfachsten Schemata, das Star und das Fact
Constellation Schema, umsetzen.
7.8.3.5.1
DAS STAR-SCHEMA
Das Star-Schema wird durch einen BFT, in welchem auch die Aggregate gespeichert
werden, charakterisiert. Die Dimensionstabellen sind sternförmig um diesen BFT
angeordnet. Wichtig ist das Level Attribut, da dieses eine Unterscheidung zwischen
atomaren und aggregierten Daten erlaubt.
- 184 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 75: Der Aufbau eines Star Schemas als Basis der CREATE TABLE Anweisungen
I_Key
K0001
K0001
K0001
K0001
K0001
K0001
K0001
K0002
K0002
K0002
K0002
K0003
K0003
K0003
K0003
K0003
K5000
K5000
K5000
K5700
K5700
K9999
K9999
K9999
K9999
C_Key
K00001
K00001
K00001
K00002
K00002
K00002
K00003
K00001
K00001
K00001
K00001
K00001
K00001
K00001
K00002
K00003
K00001
K00002
K00003
K00002
K00003
K00001
K00002
K00003
K99999
P_Key
K000001
K900001
K999001
K000001
K000002
K900001
K000001
K000001
K000002
K900001
K999001
K000002
K900001
K999001
K000001
K000001
K000001
K000001
K000001
K000001
K000001
K000001
K000001
K000001
K000001
Qty_Sold Revenue
1000
1200
19000
22800
110100
110101
700
840
980
1470
17890
21468
900
1080
1111
1667
1100
1650
17150
25725
89600
134400
10000
9000
16900
15210
96100
86490
20000
18000
4000
3600
2111
2867
700
840
900
1080
20000
18000
4000
3600
2111
2867
20700
18840
4900
4680
27711
26387
Tabelle 11: Beispielhafter BFT für die Anwendung
- 185 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
C_Key
K00001
K00002
K00003
K19999
K29999
K99999
C_cu
9876543
9874321
8912345
*
*
*
C_description
Woolworth
K-Mart
Mc Donalds
*
*
*
C_gr
1
1
2
1
2
*
C_gr_description
foodstore
foodstore
fastfood
foodstore
fastfood
*
level
0
0
0
1
1
2
address
207, View Rd, NSW, 9910
12, Creek Ave, NSW, 6677
403, Flood St, NSW, 1109
Tabelle 12: Beispielhafter Customer-Dimensionstable für die Anwendung
I_Key
K0001
K0002
K0003
K5000
K5700
K9999
I_it
1234567
12345789
2345678
*
*
*
I_description
Oranges Naval - S. A.
Banana Rosa - Victoria
Milk - Dairy Farmers
*
*
*
I_ty
1
1
2
1
2
*
I_ty_description level
fruits
0
fruits
0
diary
0
fruits
1
diary
1
*
2
Tabelle 13: Beispielhafter Items-Dimensionstable für die Anwendung
P_Key
K000001
K000002
K000003
K000170
K000171
K900001
K900002
K900003
K900006
K999001
P_d
1
2
3
170
171
*
*
*
*
*
P_description
1-Jan-2000
2-Jan-2000
3-Jan-2000
18-Jun-2000
19-Jun-2000
*
*
*
*
*
P_m
1
1
1
6
6
1
2
3
6
*
P_m_description
Jan, 2000
Jan, 2000
Jan, 2000
June, 2000
June, 2000
Jan, 2000
Feb, 2000
March, 2000
June, 2000
*
P_y
1
1
1
1
1
1
1
1
1
1
P_y_description
2000
2000
2000
2000
2000
2000
2000
2000
2000
2000
level
0
0
0
0
0
1
1
1
1
2
Tabelle 14: Beispielhafter Time-Dimensionstable für die Anwendung
7.8.3.5.2
DAS FACT CONSTELLATION SCHEMA
Bei Fact Constellation-Schema werden die Aggregate in separaten Fact Tables (FT)
gespeichert. Das führt zu mehreren, aber kleineren Tabellen.
- 186 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 76: Beispielhafte Auflistung der Dimension Tables und der Fact Tables beim Fact
Constellation-Schema
7.8.3.5.3
7.8.3.5.3.1
BEISPIELHAFTES UMSETZEN DER TABLES DURCH DAS PROGRAMM
DIE AUSGANGSPOSITION
Wir gehen für wie in 7.6.7.3 von einem Demo APA aus und domonstrieren die
Ergebnisse der SQL Scripts. Unser APA hat 3 Dimensionen (Agenten, Kunden, und
Zeit). Diese haben wiederum unterschiedliche Hierarchiestufen, welche in Abbildung
77 im Detail aufgelistet sind. Zusätzlich haben wir den „Key figure“ Umsatz vom Typ
- 187 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Money.
Abbildung 77: Input Screen des Demo APA
Die Heuristik ergibt das in Abbildung 78 angeführte Ergebnis. Dabei werden 6
materialisierte Würfel erzeugt. Nun kann der BFT, die Dimension Tabellen und die
aggregierten Views in unterschiedlichen physischen Tabellenstrukturen abgespeichert
werden. Ich habe in der Software die Strukturen für das Star-Schema und das Fact
Constellation-Schema integriert. Die Ergebnisse werden in den nachfolgenden Kapiteln
aufgelistet. Dabei wird beim Star-Schema ein BFT und drei Dimension Tables erzeugt.
Die materialisierten Würfel werden im BFT integriert und durch hinzufügen des LevelAttributes kann man durch Querys unterscheiden, ob es sich um atomare Daten oder
einen aggregierten Würfel handelt. Beim Fact Constellation-Schema enthält der BFT
nur die atomaren Daten. Die Dimensionstabellen enthalten zusätzlich
Fremdschlüsselwerte für jede Hierarchiestufe. Die materialisierten Sichten werden in
separaten Aggregated Fact Tables gespeichert.
- 188 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 78: APA Grid Screen des Demo APA
7.8.3.5.3.2
DIE SCRIPTS FÜR DAS STAR SCHEMA
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[FK_BFT_Agenten_table]')
and OBJECTPROPERTY(id, N'IsForeignKey') = 1)
ALTER TABLE [dbo].[BFT] DROP CONSTRAINT
FK_BFT_Agenten_table
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[Agenten_table]') and
OBJECTPROPERTY(id, N'IsUserTable') = 1)
drop table [dbo].[Agenten_table]
GO
CREATE TABLE [dbo].[Agenten_table] (
[Agenten_id] [varchar] (50) COLLATE
Latin1_General_CI_AS NOT NULL ,
[A_id] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[A_id_desc] [varchar] (40) COLLATE
Latin1_General_CI_AS NOT NULL ,
[A_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[A_*_desc] [varchar] (40) COLLATE Latin1_General_CI_AS
NOT NULL ,
[level] [bigint] NOT NULL
) ON [PRIMARY]
GO
- 189 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
ALTER TABLE [dbo].[Agenten_table] WITH NOCHECK ADD
CONSTRAINT [PK_Agenten_table] PRIMARY KEY CLUSTERED
(
[Agenten_id]
) ON [PRIMARY]
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[FK_BFT_Kunden_table]')
and OBJECTPROPERTY(id, N'IsForeignKey') = 1)
ALTER TABLE [dbo].[BFT] DROP CONSTRAINT FK_BFT_Kunden_table
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[Kunden_table]') and
OBJECTPROPERTY(id, N'IsUserTable') = 1)
drop table [dbo].[Kunden_table]
GO
CREATE TABLE [dbo].[Kunden_table] (
[Kunden_id] [varchar] (50) COLLATE
Latin1_General_CI_AS NOT NULL ,
[K_id] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[K_id_desc] [varchar] (40) COLLATE
Latin1_General_CI_AS NOT NULL ,
[K_gr] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[K_gr_desc] [varchar] (40) COLLATE
Latin1_General_CI_AS NOT NULL ,
[K_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[K_*_desc] [varchar] (40) COLLATE Latin1_General_CI_AS
NOT NULL ,
[level] [bigint] NOT NULL
) ON [PRIMARY]
GO
ALTER TABLE [dbo].[Kunden_table] WITH NOCHECK ADD
CONSTRAINT [PK_Kunden_table] PRIMARY KEY CLUSTERED
(
[Kunden_id]
) ON [PRIMARY]
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[FK_BFT_Zeit_table]')
and OBJECTPROPERTY(id, N'IsForeignKey') = 1)
- 190 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
ALTER TABLE [dbo].[BFT] DROP CONSTRAINT FK_BFT_Zeit_table
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[Zeit_table]') and
OBJECTPROPERTY(id, N'IsUserTable') = 1)
drop table [dbo].[Zeit_table]
GO
CREATE TABLE [dbo].[Zeit_table] (
[Zeit_id] [varchar] (50) COLLATE Latin1_General_CI_AS
NOT NULL ,
[Z_t] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[Z_t_desc] [varchar] (40) COLLATE Latin1_General_CI_AS
NOT NULL ,
[Z_m] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[Z_m_desc] [varchar] (40) COLLATE Latin1_General_CI_AS
NOT NULL ,
[Z_y] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[Z_y_desc] [varchar] (40) COLLATE Latin1_General_CI_AS
NOT NULL ,
[Z_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[Z_*_desc] [varchar] (40) COLLATE Latin1_General_CI_AS
NOT NULL ,
[level] [bigint] NOT NULL
) ON [PRIMARY]
GO
ALTER TABLE [dbo].[Zeit_table] WITH NOCHECK ADD
CONSTRAINT [PK_Zeit_table] PRIMARY KEY CLUSTERED
(
[Zeit_id]
) ON [PRIMARY]
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[BFT]')
and OBJECTPROPERTY(id, N'IsUserTable') = 1)
drop table [dbo].[BFT]
GO
CREATE TABLE [dbo].[BFT] (
[Agenten_id] [varchar] (50) COLLATE
Latin1_General_CI_AS NOT NULL ,
- 191 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
[Kunden_id] [varchar] (50) COLLATE
Latin1_General_CI_AS NOT NULL ,
[Zeit_id] [varchar] (50) COLLATE Latin1_General_CI_AS
NOT NULL ,
[Umsatz] [MONEY] NOT NULL
) ON [PRIMARY]
GO
ALTER TABLE [dbo].[BFT] WITH NOCHECK ADD
CONSTRAINT [PK_BFT] PRIMARY KEY CLUSTERED
(
[Agenten_id],
[Kunden_id],
[Zeit_id]
) ON [PRIMARY]
GO
ALTER TABLE [dbo].[BFT] ADD
CONSTRAINT [FK_BFT_Agenten_table] FOREIGN KEY
(
[Agenten_id]
) REFERENCES [dbo].[Agenten_table] (
[Agenten_id]
) ON UPDATE CASCADE
GO
ALTER TABLE [dbo].[BFT] ADD
CONSTRAINT [FK_BFT_Kunden_table] FOREIGN KEY
(
[Kunden_id]
) REFERENCES [dbo].[Kunden_table] (
[Kunden_id]
) ON UPDATE CASCADE
GO
ALTER TABLE [dbo].[BFT] ADD
CONSTRAINT [FK_BFT_Zeit_table] FOREIGN KEY
(
[Zeit_id]
) REFERENCES [dbo].[Zeit_table] (
[Zeit_id]
) ON UPDATE CASCADE
GO
- 192 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.8.3.5.3.3
DIE SCRIPTS FÜR DAS FACT CONSTELLATION SCHEMA
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[FK_BFT_Agenten_table]')
and OBJECTPROPERTY(id, N'IsForeignKey') = 1)
ALTER TABLE [dbo].[BFT] DROP CONSTRAINT
FK_BFT_Agenten_table
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[Agenten_table]') and
OBJECTPROPERTY(id, N'IsUserTable') = 1)
drop table [dbo].[Agenten_table]
GO
CREATE TABLE [dbo].[Agenten_table] (
[Agenten_id] [varchar] (50) COLLATE
Latin1_General_CI_AS NOT NULL ,
[A_id] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[A_id_desc] [varchar] (40) COLLATE
Latin1_General_CI_AS NOT NULL ,
[A_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[A_*_desc] [varchar] (40) COLLATE Latin1_General_CI_AS
NOT NULL ,
) ON [PRIMARY]
GO
ALTER TABLE [dbo].[Agenten_table] WITH NOCHECK ADD
CONSTRAINT [PK_Agenten_table] PRIMARY KEY CLUSTERED
(
[Agenten_id]
) ON [PRIMARY]
GO
CREATE INDEX [IX_A_id] ON [dbo].[Agenten_table]([A_id])
ON [PRIMARY]
GO
CREATE INDEX [IX_A_*] ON [dbo].[Agenten_table]([A_*]) ON
[PRIMARY]
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[FK_BFT_Kunden_table]')
and OBJECTPROPERTY(id, N'IsForeignKey') = 1)
ALTER TABLE [dbo].[BFT] DROP CONSTRAINT FK_BFT_Kunden_table
GO
- 193 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[Kunden_table]') and
OBJECTPROPERTY(id, N'IsUserTable') = 1)
drop table [dbo].[Kunden_table]
GO
CREATE TABLE [dbo].[Kunden_table] (
[Kunden_id] [varchar] (50) COLLATE
Latin1_General_CI_AS NOT NULL ,
[K_id] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[K_id_desc] [varchar] (40) COLLATE
Latin1_General_CI_AS NOT NULL ,
[K_gr] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[K_gr_desc] [varchar] (40) COLLATE
Latin1_General_CI_AS NOT NULL ,
[K_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[K_*_desc] [varchar] (40) COLLATE Latin1_General_CI_AS
NOT NULL ,
) ON [PRIMARY]
GO
ALTER TABLE [dbo].[Kunden_table] WITH NOCHECK ADD
CONSTRAINT [PK_Kunden_table] PRIMARY KEY CLUSTERED
(
[Kunden_id]
) ON [PRIMARY]
GO
CREATE INDEX [IX_K_id] ON [dbo].[Kunden_table]([K_id]) ON
[PRIMARY]
GO
CREATE INDEX [IX_K_gr] ON [dbo].[Kunden_table]([K_gr]) ON
[PRIMARY]
GO
CREATE INDEX [IX_K_*] ON [dbo].[Kunden_table]([K_*]) ON
[PRIMARY]
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[FK_BFT_Zeit_table]')
and OBJECTPROPERTY(id, N'IsForeignKey') = 1)
ALTER TABLE [dbo].[BFT] DROP CONSTRAINT FK_BFT_Zeit_table
GO
- 194 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[Zeit_table]') and
OBJECTPROPERTY(id, N'IsUserTable') = 1)
drop table [dbo].[Zeit_table]
GO
CREATE TABLE [dbo].[Zeit_table] (
[Zeit_id] [varchar] (50) COLLATE Latin1_General_CI_AS
NOT NULL ,
[Z_t] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[Z_t_desc] [varchar] (40) COLLATE Latin1_General_CI_AS
NOT NULL ,
[Z_m] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[Z_m_desc] [varchar] (40) COLLATE Latin1_General_CI_AS
NOT NULL ,
[Z_y] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[Z_y_desc] [varchar] (40) COLLATE Latin1_General_CI_AS
NOT NULL ,
[Z_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[Z_*_desc] [varchar] (40) COLLATE Latin1_General_CI_AS
NOT NULL ,
) ON [PRIMARY]
GO
ALTER TABLE [dbo].[Zeit_table] WITH NOCHECK ADD
CONSTRAINT [PK_Zeit_table] PRIMARY KEY CLUSTERED
(
[Zeit_id]
) ON [PRIMARY]
GO
CREATE INDEX [IX_Z_t] ON [dbo].[Zeit_table]([Z_t]) ON
[PRIMARY]
GO
CREATE INDEX [IX_Z_m] ON [dbo].[Zeit_table]([Z_m]) ON
[PRIMARY]
GO
CREATE INDEX [IX_Z_y] ON [dbo].[Zeit_table]([Z_y]) ON
[PRIMARY]
GO
- 195 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
CREATE INDEX [IX_Z_*] ON [dbo].[Zeit_table]([Z_*]) ON
[PRIMARY]
GO
if exists (select * from dbo.sysobjects where id =
object_id(N'[dbo].[BFT]')
and OBJECTPROPERTY(id, N'IsUserTable') = 1)
drop table [dbo].[BFT]
GO
CREATE TABLE [dbo].[BFT] (
[Agenten_id] [varchar] (50) COLLATE
Latin1_General_CI_AS NOT NULL ,
[Kunden_id] [varchar] (50) COLLATE
Latin1_General_CI_AS NOT NULL ,
[Zeit_id] [varchar] (50) COLLATE Latin1_General_CI_AS
NOT NULL ,
[Umsatz] [MONEY] NOT NULL
) ON [PRIMARY]
GO
ALTER TABLE [dbo].[BFT] WITH NOCHECK ADD
CONSTRAINT [PK_BFT] PRIMARY KEY CLUSTERED
(
[Agenten_id],
[Kunden_id],
[Zeit_id]
) ON [PRIMARY]
GO
ALTER TABLE [dbo].[BFT] ADD
CONSTRAINT [FK_BFT_Agenten_table] FOREIGN KEY
(
[Agenten_id]
) REFERENCES [dbo].[Agenten_table] (
[Agenten_id]
) ON UPDATE CASCADE
GO
ALTER TABLE [dbo].[BFT] ADD
CONSTRAINT [FK_BFT_Kunden_table] FOREIGN KEY
(
[Kunden_id]
) REFERENCES [dbo].[Kunden_table] (
[Kunden_id]
) ON UPDATE CASCADE
GO
- 196 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
ALTER TABLE [dbo].[BFT] ADD
CONSTRAINT [FK_BFT_Zeit_table] FOREIGN KEY
(
[Zeit_id]
) REFERENCES [dbo].[Zeit_table] (
[Zeit_id]
) ON UPDATE CASCADE
GO
if exists (select * from dbo.sysobjects where
id = object_id(N'[dbo].[FT A_*K_idZ_m]') and
OBJECTPROPERTY(id, N'IsUserTable') = 1)
drop table [dbo].[FT A_*K_idZ_m]
GO
CREATE TABLE [dbo].[FT A_*K_idZ_m] (
[A_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[K_id] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[Z_m] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[Umsatz] [MONEY] NOT NULL
) ON [PRIMARY]
GO
ALTER TABLE [dbo].[FT A_*K_idZ_m] WITH NOCHECK ADD
CONSTRAINT [PK_FT A_*K_idZ_m] PRIMARY KEY CLUSTERED
(
[A_*] ,
[K_id] ,
[Z_m]
) ON [PRIMARY]
GO
if exists (select * from dbo.sysobjects where
id = object_id(N'[dbo].[FT A_idK_*Z_t]') and
OBJECTPROPERTY(id, N'IsUserTable') = 1)
drop table [dbo].[FT A_idK_*Z_t]
GO
CREATE TABLE [dbo].[FT A_idK_*Z_t] (
[A_id] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
- 197 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
[K_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[Z_t] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[Umsatz] [MONEY] NOT NULL
) ON [PRIMARY]
GO
ALTER TABLE [dbo].[FT A_idK_*Z_t] WITH NOCHECK ADD
CONSTRAINT [PK_FT A_idK_*Z_t] PRIMARY KEY CLUSTERED
(
[A_id] ,
[K_*] ,
[Z_t]
) ON [PRIMARY]
GO
if exists (select * from dbo.sysobjects where
id = object_id(N'[dbo].[FT A_*K_*Z_t]') and
OBJECTPROPERTY(id, N'IsUserTable') = 1)
drop table [dbo].[FT A_*K_*Z_t]
GO
CREATE TABLE [dbo].[FT A_*K_*Z_t] (
[A_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[K_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[Z_t] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[Umsatz] [MONEY] NOT NULL
) ON [PRIMARY]
GO
ALTER TABLE [dbo].[FT A_*K_*Z_t] WITH NOCHECK ADD
CONSTRAINT [PK_FT A_*K_*Z_t] PRIMARY KEY CLUSTERED
(
[A_*] ,
[K_*] ,
[Z_t]
) ON [PRIMARY]
GO
if exists (select * from dbo.sysobjects where
id = object_id(N'[dbo].[FT A_*K_idZ_y]') and
OBJECTPROPERTY(id, N'IsUserTable') = 1)
drop table [dbo].[FT A_*K_idZ_y]
- 198 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
GO
CREATE TABLE [dbo].[FT A_*K_idZ_y] (
[A_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[K_id] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[Z_y] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[Umsatz] [MONEY] NOT NULL
) ON [PRIMARY]
GO
ALTER TABLE [dbo].[FT A_*K_idZ_y] WITH NOCHECK ADD
CONSTRAINT [PK_FT A_*K_idZ_y] PRIMARY KEY CLUSTERED
(
[A_*] ,
[K_id] ,
[Z_y]
) ON [PRIMARY]
GO
if exists (select * from dbo.sysobjects where
id = object_id(N'[dbo].[FT A_idK_*Z_m]') and
OBJECTPROPERTY(id, N'IsUserTable') = 1)
drop table [dbo].[FT A_idK_*Z_m]
GO
CREATE TABLE [dbo].[FT A_idK_*Z_m] (
[A_id] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[K_*] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[Z_m] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[Umsatz] [MONEY] NOT NULL
) ON [PRIMARY]
GO
ALTER TABLE [dbo].[FT A_idK_*Z_m] WITH NOCHECK ADD
CONSTRAINT [PK_FT A_idK_*Z_m] PRIMARY KEY CLUSTERED
(
[A_id] ,
[K_*] ,
[Z_m]
) ON [PRIMARY]
GO
- 199 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if exists (select * from dbo.sysobjects where
id = object_id(N'[dbo].[FT A_idK_grZ_y]') and
OBJECTPROPERTY(id, N'IsUserTable') = 1)
drop table [dbo].[FT A_idK_grZ_y]
GO
CREATE TABLE [dbo].[FT A_idK_grZ_y] (
[A_id] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[K_gr] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[Z_y] [varchar] (12) COLLATE Latin1_General_CI_AS NOT
NULL ,
[Umsatz] [MONEY] NOT NULL
) ON [PRIMARY]
GO
ALTER TABLE [dbo].[FT A_idK_grZ_y] WITH NOCHECK ADD
CONSTRAINT [PK_FT A_idK_grZ_y] PRIMARY KEY CLUSTERED
(
[A_id] ,
[K_gr] ,
[Z_y]
) ON [PRIMARY]
GO
7.9 ERGEBNISSE DER TESTS DER HEURISTIKEN
Um die Funktionalität der Heuristik zu überprüfen, ist es essentiell die richtige Lösung
deterministisch durch einen Algorithmus zu bestimmen. Diese Algorithmen wurden in
den vorhergehenden Kapiteln eingehend behandelt. Dabei wurde sowohl bei der
Permutation als auch bei der Kombination gleiche Ergebnisse erzielt.
7.9.1 PROBLEME BEI TESTEN DER HEURISTIK
Der erste Ansatz war das Testen der Ergebnisse der Heuristik im Vergleich zu den
Ergebnissen der deterministischen Lösung durch die Permutation. Dabei wurden alle
möglichen Sequenzen der zu materialisierenden Cubes unter der Berücksichtigung der
Reihenfolge der Cubes berechnet und die kostenminimale Lösung mit der Heuristik
verglichen. Unglücklicherweise dauert das Berechnen dieser deterministischen Lösung
sehr lange. Das führte sogar bei kleinen APA zu Berechnungszeiten über 1 Jahr.
- 200 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Deshalb wurde in einem zweiten Schritt der Ansatz über die Kombination gewählt.
Dabei wurde die Materialisierungsreihenfolge der Cubes nicht beachtet. Das führte zu
wesentlich weniger Sequenzen, welche in einem zweiten Schritt dann durch den
Algorithmus von Dijkstra, welcher in den Algorithmus GetRightOrder eingebaut wurde,
in die optimale Reihenfolge gebracht. Dadurch konnten akzeptable Berechnungszeiten
von 3 bis 4 Wochen Berechnungszeit für kleine bis mittelgroße APA erreicht werden.
Durch den Einsatz von 4 Rechnern parallel wurden die unten angeführten Ergebnisse
erreicht.
Zusätzlich wurde eine spezielle eine Abbruchbedingung eingeführt. Wenn die
Kombination von z.B. 6 Cubes in jeder möglichen Kombination immer die Spacemax
Bedingung überschritten hat, ist logischerweise auch bei einer Kombination von 7
Cubes das Spacemax Limit überschritten. Deshalb konnte die Berechnung früher
gestoppt werden. Aus diesem Grund wurde auch in den empirischen Probeläufen von
einem sehr geringen verfügbaren Speicherplatz ausgegangen. Nur so konnten die
Berechnungszeiten von bis zu 4 Wochen erreicht werden.
Die Menge der betrachteten Cubes wurden auf die so genannten „Possible Cubes“
eingeschränkt. Dabei würden aus der Gesamtmenge aller Cubes jene Cubes
ausgeklammert, welche jedenfalls keinen positiven Beitrag zur Berechnung der
Required Cubes leisten könnten. So sieht man in Abbildung 79 die mit schwarz
markierten Menge der Possible Cubes. Der beispielhaft aktivierte Cube (4:2): K_gr;
A_*; Z_* bringt dabei keinen zusätzlichen Nutzen für die Materialisierung der Required
Cubes, da keines seiner Derivative ein Required Cube ist. Aus diesem Grund befindet
sich dieser Cube nicht in der Menge der Possible Cubes.
- 201 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 79: Demonstrative Anzeigen der Possible Cubes
7.9.2 GESAMTÜBERSICHT ÜBER DIE ERGEBNISSE
Bezeichnung
Kosten
KostenSpaceleft
Timeleft
übereinstimmung Übereinstimmung Übereinstimmung
Test1
Strukturierte
Zufallskosten
100 %
100 %
100 %
Test2
Strukturierte
Zufallskosten
100 %
100 %
100 %
Test3
Strukturierte
Zufallskosten
100 %
100 %
100 %
Test4
Strukturierte
Zufallskosten
100 %
100 %
100 %
Test5
Strukturierte
Zufallskosten
100 %
100 %
100 %
- 202 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Test6
Strukturierte
Zufallskosten
100 %
100 %
100 %
Test7
Strukturierte
Zufallskosten
100 %
100 %
100 %
Test8
Total Random
Zufallskosten
100 %
100 %
100 %
Test9
Total Random
Zufallskosten
100 %
100 %
100 %
Test10
Total Random
Zufallskosten
100 %
100 %
100 %
Test11
Total Random
Zufallskosten
100 %
100 %
100 %
Test12
Total Random
Zufallskosten
100 %
100 %
100 %
Test13
Mit
Kostenfunktion
100 %
100 %
100 %
Test14
Total Random
Zufallskosten
100 %
100 %
100 %
Test15
Total Random
Zufallskosten
100 %
100 %
100 %
Test16
Mit
Kostenfunktion
100 %
100 %
100 %
Test17
Strukturierte
Zufallskosten
100 %
100 %
100 %
Test18
Mit
Kostenfunktion
4,53 %
10,73 %
26,33 %
- 203 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3 DIE ERGEBNISSE IM DETAIL
7.9.3.1
7.9.3.1.1
Required
Cubes:
1
2
3
4
5
6
7
8
7.9.3.1.2
VORGABEN UND ERGEBNISSE TEST 1
VORGABEN
3:0 K_*; A_*; G_*; Z_t
3:2 K_*; A_id; G_*; Z_m
4:2 K_*; A_id; G_*; Z_y
2:4 K_gr; A_*; G_*; Z_t
1:7 K_gr; A_id; G_b; Z_m
2:7 K_gr; A_id; G_b; Z_y
3:7 K_gr; A_id; G_b; Z_*
1:10 K_id; A_id; G_*; Z_m
count
10000
10000
10000
10000
10000
10000
10000
10000
Parameter
Spacemax
500000
Timemax
2500000
Zeitkosten
1 bis 100000
Size per Tupel in Bytes:
64
New set on each iteration
4
Max Sets
20
LÖSUNG DER HEURISTIK
- 204 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.1.3
DETERMINISTISCHE LÖSUNG
7.9.3.1.4
VERGLEICH DER ERGEBNISSE
Parameter Heuristik
Deterministisch Abweichung
Kosten
971499585
971499585
0,00%
Space left
185952
185952
0,00%
Time left
40415
40415
0,00%
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte
den richtigen Wert im Lösungsweg 1.
7.9.3.2
7.9.3.2.1
Required
Cubes:
1
2
3
4
5
6
7
8
VORGABEN UND ERGEBNISSE TEST 2
VORGABEN
4:1 K_*; A_*; G_b; Z_m
5:1 K_*; A_*; G_b; Z_y
6:1 K_*; A_*; G_b; Z_*
3:7 K_gr; A_*; G_b; Z_m
4:7 K_gr; A_*; G_b; Z_y
2:14 K_id; A_gr; G_*; Z_m
3:14 K_id; A_gr; G_*; Z_y
4:14 K_id; A_gr; G_*; Z_*
count
1000
1000
1000
1000
1000
1000
1000
1000
Parameter
Spacemax
100000
Timemax
1500000
Zeitkosten
1 bis 100000
Size per Tupel in Bytes:
64
New set on each iteration
4
Max Sets
20
- 205 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.2.2
LÖSUNG DER HEURISTIK
7.9.3.2.3
DETERMINISTISCHE LÖSUNG
- 206 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.2.4
VERGLEICH DER ERGEBNISSE
Parameter Heuristik
Deterministisch Abweichung
Kosten
2951750032
2951750032
0,00%
Space left
335040
335040
0,00%
Time left
1399968
1399968
0,00%
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte
den richtigen Wert im Lösungsweg 1.
7.9.3.3
7.9.3.3.1
Required
Cubes:
1
2
3
4
5
6
7
8
7.9.3.3.2
VORGABEN UND ERGEBNISSE TEST 3
VORGABEN
0:0 K_gr; A_id; G_b; Z_t
1:0 K_*; A_id; G_b; Z_t
4:0 K_*; A_*; G_*; Z_m
5:0 K_*; A_*; G_*; Z_y
6:0 K_*; A_*; G_*; Z_*
1:10 K_id; A_id; G_*; Z_m
2:10 K_id; A_id; G_*; Z_y
3:10 K_id; A_id; G_*; Z_*
count
1000
1000
1000
1000
1000
1000
1000
1000
Parameter
Spacemax
500000
Timemax
1500000
Zeitkosten
1 bis 100000
Size per Tupel in Bytes:
64
New set on each iteration
4
Max Sets
20
LÖSUNG DER HEURISTIK
- 207 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.3.3
DETERMINISTISCHE LÖSUNG
7.9.3.3.4
VERGLEICH DER ERGEBNISSE
Parameter Heuristik
Deterministisch Abweichung
Kosten
2950860
2950860
0,00%
Space left
2265920
2265920
0,00%
Time left
1489441
1489441
0,00%
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte
den richtigen Wert im Lösungsweg 2.
- 208 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.4
7.9.3.4.1
Required
Cubes:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
7.9.3.4.2
VORGABEN UND ERGEBNISSE TEST 4
VORGABEN
0:0 K_gr; A_id; Z_t
1:0 K_*; A_id; Z_t
2:0 K_*; A_*; Z_t
2:1 K_*; A_id; Z_m
1:2 K_gr; A_*; Z_t
2:2 K_gr; A_*; Z_m
3:2 K_gr; A_*; Z_y
1:3 K_gr; A_id; Z_m
2:3 K_gr; A_id; Z_y
0:4 K_id; A_*; Z_t
1:4 K_id; A_*; Z_m
2:4 K_id; A_*; Z_y
0:5 K_id; A_id; Z_m
1:5 K_id; A_id; Z_y
2:5 K_id; A_id; Z_*
count
10000
1000
1000
1000
10000
1000
1000
1000
1000
1000
1000
1000
10000
10000
10000
Parameter
Spacemax
500000000
Timemax
1500000
Zeitkosten
1 bis 100000
Size per Tupel in Bytes:
900
New set on each iteration
4
Max Sets
20
LÖSUNG DER HEURISTIK
- 209 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.4.3
DETERMINISTISCHE LÖSUNG
7.9.3.4.4
VERGLEICH DER ERGEBNISSE
Parameter Heuristik
Deterministisch Abweichung
Kosten
253922
253922
0,00%
Space left
212414000
212414000
0,00%
Time left
1246080
1246080
0,00%
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte
den richtigen Wert im Lösungsweg 1.
- 210 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.5
7.9.3.5.1
Required
Cubes:
1
2
3
4
5
6
7
8
9
7.9.3.5.2
VORGABEN UND ERGEBNISSE TEST 5
VORGABEN
2:0 A_*; K_*; Z_t
1:2 A_*; K_id; Z_m
2:2 A_*; K_id; Z_y
3:2 A_*; K_id; Z_*
1:3 A_id; K_*; Z_t
2:3 A_id; K_*; Z_m
2:4 A_id; K_gr; Z_y
1:5 A_id; K_id; Z_y
2:5 A_id; K_id; Z_*
count
10000
1000
1000
1000
10000
10000
10000
1
1
Parameter
Spacemax
500000000
Timemax
1500000
Zeitkosten
1 bis 100000
Size per Tupel in Bytes:
900
New set on each iteration
4
Max Sets
20
LÖSUNG DER HEURISTIK
- 211 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.5.3
DETERMINISTISCHE LÖSUNG
7.9.3.5.4
VERGLEICH DER ERGEBNISSE
Parameter Heuristik
Deterministisch Abweichung
Kosten
99578
99578
0,00%
Space left
42400400
42400400
0,00%
Time left
1438916
1438916
0,00%
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte
den richtigen Wert im Lösungsweg 1.
- 212 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.6
7.9.3.6.1
Required
Cubes:
1
2
3
4
5
6
7
8
9
10
11
12
13
7.9.3.6.2
VORGABEN UND ERGEBNISSE TEST 6
VORGABEN
0:0 K_gr; A_id; Z_t
1:0 K_*; A_id; Z_t
2:0 K_*; A_gr; Z_t
1:3 K_gr; A_gr; Z_t
2:3 K_gr; A_*; Z_t
1:5 K_gr; A_id; Z_m
2:5 K_gr; A_id; Z_y
3:5 K_gr; A_id; Z_*
0:6 K_id; A_gr; Z_t
1:6 K_id; A_*; Z_t
3:6 K_id; A_*; Z_y
4:6 K_id; A_*; Z_*
2:7 K_id; A_gr; Z_y
count
1000
1000
10000
1000
1000
10000
10000
10000
1
1000
10000
10000
1000
Parameter
Spacemax
58000000
Timemax
1500000
Zeitkosten
1 bis 100000
Size per Tupel in Bytes:
900
New set on each iteration
4
Max Sets
20
LÖSUNG DER HEURISTIK
- 213 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.6.3
DETERMINISTISCHE LÖSUNG
7.9.3.6.4
VERGLEICH DER ERGEBNISSE
Parameter Heuristik
Deterministisch Abweichung
Kosten
2639020
2639020
0,00%
Space left
1461847
1461847
0,00%
Time left
2576200
2576200
0,00%
Es konnte eine eindeutige Übereinstimmung festgestellt werden. In der
Materialisierungsreihenfolge wurde jedoch eine andere Reihenfolge gewählt. Dies
beeinflusst aber nicht die Kosten. Die Heuristik lieferte den richtigen Wert im
Lösungsweg 1.
- 214 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.7
7.9.3.7.1
Required
Cubes:
1
2
3
4
5
6
7
8
9
10
11
12
13
7.9.3.7.2
VORGABEN UND ERGEBNISSE TEST 7
VORGABEN
3:0 K_*; G_*; Z_t
2:3 K_gr; G_*; Z_t
3:3 K_gr; G_*; Z_m
4:3 K_gr; G_*; Z_y
5:3 K_gr; G_*; Z_*
1:5 K_gr; G_b; Z_m
2:5 K_gr; G_b; Z_y
3:5 K_gr; G_b; Z_*
1:6 K_id; G_*; Z_t
2:6 K_id; G_*; Z_m
3:6 K_id; G_*; Z_y
4:6 K_id; G_*; Z_*
1:8 K_id; G_b; Z_y
count
10000
10000
10000
10000
10000
1000
1000
1000
10000
10000
10000
10000
10000
Parameter
Spacemax
8000000
Timemax
1500000
Zeitkosten
1 bis 100000
Size per Tupel in Bytes:
120
New set on each iteration
4
Max Sets
20
LÖSUNG DER HEURISTIK
- 215 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.7.3
DETERMINISTISCHE LÖSUNG
7.9.3.7.4
VERGLEICH DER ERGEBNISSE
Parameter Heuristik
Deterministisch Abweichung
Kosten
1278025457
1278025457
0,00%
Space left
997040
997040
0,00%
Time left
14824543
14824543
0,00%
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte
den richtigen Wert im Lösungsweg 2.
- 216 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.8
7.9.3.8.1
Required
Cubes:
1
2
3
4
5
6
7
8
9
10
11
12
13
7.9.3.8.2
VORGABEN UND ERGEBNISSE TEST 8
VORGABEN
3:0 K_*; G_*; Z_t
2:3 K_gr; G_*; Z_t
3:3 K_gr; G_*; Z_m
4:3 K_gr; G_*; Z_y
5:3 K_gr; G_*; Z_*
1:5 K_gr; G_b; Z_m
2:5 K_gr; G_b; Z_y
3:5 K_gr; G_b; Z_*
1:6 K_id; G_*; Z_t
2:6 K_id; G_*; Z_m
3:6 K_id; G_*; Z_y
4:6 K_id; G_*; Z_*
1:8 K_id; G_b; Z_y
count
10000
10000
10000
10000
10000
1000
1000
1000
10000
10000
10000
10000
10000
Parameter
Spacemax
8000000
Timemax
1500000
Zeitkosten
1 bis 100000
Size per Tupel in Bytes:
120
New set on each iteration
4
Max Sets
20
LÖSUNG DER HEURISTIK
- 217 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.8.3
DETERMINISTISCHE LÖSUNG
7.9.3.8.4
VERGLEICH DER ERGEBNISSE
Parameter Heuristik
Deterministisch Abweichung
Kosten
29369605
29369605
0,00%
Space left
592760
592760
0,00%
Time left
14920395
14920395
0,00%
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte
den richtigen Wert im Lösungsweg 2.
- 218 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.9
7.9.3.9.1
Required
Cubes:
1
2
3
4
5
6
7
8
9
10
11
12
13
7.9.3.9.2
VORGABEN UND ERGEBNISSE TEST 9
VORGABEN
0:0 K_gr; A_id; Z_t
1:0 K_*; A_id; Z_t
2:0 K_*; A_gr; Z_t
1:3 K_gr; A_gr; Z_t
2:3 K_gr; A_*; Z_t
1:5 K_gr; A_id; Z_m
2:5 K_gr; A_id; Z_y
3:5 K_gr; A_id; Z_*
0:6 K_id; A_gr; Z_t
1:6 K_id; A_*; Z_t
3:6 K_id; A_*; Z_y
4:6 K_id; A_*; Z_*
2:7 K_id; A_gr; Z_y
count
1000
1000
10000
1000
1000
10000
10000
10000
1
1000
10000
1000
1000
Parameter
Spacemax
58000000
Timemax
1500000
Zeitkosten
1 bis 100000
Size per Tupel in Bytes:
900
New set on each iteration
4
Max Sets
20
LÖSUNG DER HEURISTIK
- 219 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.9.3
DETERMINISTISCHE LÖSUNG
7.9.3.9.4
VERGLEICH DER ERGEBNISSE
Parameter Heuristik
Deterministisch Abweichung
Kosten
641966243
641966243
0,00%
Space left
2432200
2432200
0,00%
Time left
1261075
1261075
0,00%
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte
den richtigen Wert im Lösungsweg 2.
- 220 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.10 VORGABEN UND ERGEBNISSE TEST 10
7.9.3.10.1
Required
Cubes:
1
2
3
4
5
6
7
8
9
10
11
7.9.3.10.2
VORGABEN
2:0 K_*; A_*; G_*; Z_t
2:2 K_*; A_id; G_*; Z_m
1:3 K_*; A_id; G_b; Z_m
2:3 K_*; A_id; G_b; Z_y
3:3 K_*; A_id; G_b; Z_*
0:4 K_id; A_*; G_b; Z_t
1:4 K_id; A_*; G_*; Z_t
0:6 K_id; A_id; G_*; Z_t
1:6 K_id; A_id; G_*; Z_m
2:6 K_id; A_id; G_*; Z_y
3:6 K_id; A_id; G_*; Z_*
count
1000
10000
1000
1000
1000
1000
10000
1
1000
1000
1000
Parameter
Spacemax
200000000
Timemax
1500000
Zeitkosten
1 bis 100000
Size per Tupel in Bytes:
840
New set on each iteration
4
Max Sets
15
LÖSUNG DER HEURISTIK
- 221 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.10.3
DETERMINISTISCHE LÖSUNG
7.9.3.10.4
VERGLEICH DER ERGEBNISSE
Parameter Heuristik
Deterministisch Abweichung
Kosten
275596808
275596808
0,00%
Space left
21788960
21788960
0,00%
Time left
1252172
1252172
0,00%
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte
den richtigen Wert im Lösungsweg 1.
- 222 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.11 VORGABEN UND ERGEBNISSE TEST 11
7.9.3.11.1
Required
Cubes:
1
2
3
4
5
6
7
8
9
10
7.9.3.11.2
VORGABEN
count
3:2 K_*; A_gr; G_*; Z_m
2:3 K_*; A_gr; G_b; Z_m
3:3 K_*; A_gr; G_b; Z_y
1:4 K_*; A_id; G_*; Z_t
2:5 K_*; A_id; G_b; Z_y
1:6 K_id; A_*; G_b; Z_t
2:6 K_id; A_*; G_*; Z_t
2:7 K_id; A_*; G_b; Z_m
2:8 K_id; A_gr; G_*; Z_m
1:10 K_id; A_id; G_*; Z_m
1
10000
1
10000
10000
1000
1000
10000
10000
10000
Parameter
Spacemax
200000000
Timemax
1500000
Zeitkosten
1 bis 100000
Size per Tupel in Bytes:
840
New set on each iteration
4
Max Sets
15
LÖSUNG DER HEURISTIK
- 223 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.11.3
DETERMINISTISCHE LÖSUNG
7.9.3.11.4
VERGLEICH DER ERGEBNISSE
Parameter Heuristik
Deterministisch Abweichung
Kosten
447157299
447157299
0,00%
Space left
1328590
1328590
0,00%
Time left
27595880
27595880
0,00%
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte
den richtigen Wert im Lösungsweg 1.
- 224 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.12 VORGABEN UND ERGEBNISSE TEST 12
7.9.3.12.1
Required
Cubes:
1
2
3
4
5
6
7
8
9
10
11
12
13
VORGABEN
3:0 K_*; G_*; Z_t
2:3 K_gr; G_*; Z_t
3:3 K_gr; G_*; Z_m
4:3 K_gr; G_*; Z_y
5:3 K_gr; G_*; Z_*
1:5 K_gr; G_b; Z_m
2:5 K_gr; G_b; Z_y
3:5 K_gr; G_b; Z_*
1:6 K_id; G_*; Z_t
2:6 K_id; G_*; Z_m
3:6 K_id; G_*; Z_y
4:6 K_id; G_*; Z_*
1:8 K_id; G_b; Z_y
7.9.3.12.2
count
10000
10000
10000
10000
10000
1000
1000
1000
10000
10000
10000
10000
10000
Parameter
Spacemax
Timemax
Zeitkosten
Size per Tupel in Bytes:
New set on each iteration
Max Sets
LÖSUNG DER HEURISTIK
- 225 -
8000000
15000000
1 bis 100000
120
6
20
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.12.3
DETERMINISTISCHE LÖSUNG
7.9.3.12.4
VERGLEICH DER ERGEBNISSE
Parameter Heuristik
Deterministisch Abweichung
Kosten
2873774
2873774
0,00%
Space left
591320
591320
0,00%
Time left
14926226
14926226
0,00%
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte
den richtigen Wert im Lösungsweg 8.
- 226 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.13 VORGABEN UND ERGEBNISSE TEST 13
7.9.3.13.1
Required
Cubes:
1
2
3
4
5
6
7
7.9.3.13.2
VORGABEN
2:0 C_*; A_gr; T_d
3:1 C_*; A_gr; T_m
2:3 C_gr; A_*; T_d
3:3 C_gr; A_*; T_m
2:4 C_gr; A_gr; T_m
2:5 C_gr; A_id; T_y
1:6 C_id; A_*; T_d
count
10000
10000
10000
10000
10000
10000
10000
Parameter
New set on each iteration
2
Max Sets
50
average time to store a
tupel in time units
2
average time for io in time
units
2
average time for CPU
instructions in time units
0,002
max time
1500000
average time to query in
timeunits
100
average size of a tupel in
bytes
900
max space in bytes
58000000
time weight
75%
query weight
63%
LÖSUNG DER HEURISTIK
- 227 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.13.3
DETERMINISTISCHE LÖSUNG
7.9.3.13.4
VERGLEICH DER ERGEBNISSE
Parameter Heuristik
Deterministisch Abweichung
Kosten
1549,136539
1549,136539
0,00%
Space left
2339500
2339500
0,00%
Time left
396,7110032
396,7110032
0,00%
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte
den richtigen Wert im Lösungsweg 29. Damit zeigt dieser Testlauf am deutlichsten die
Grenzen der Heuristik auf. Wäre in den Parameter die Anzahl der Lösungswege auf eine
geringere Anzahl als 29 gesetzt worden, wäre das Ergebnis unrichtig. Deshalb wird im
Test 18 dieses Beispiel nochmals mit neuen Parametern ausgetestet.
- 228 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.14 VORGABEN UND ERGEBNISSE TEST 14
7.9.3.14.1
Required
Cubes:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
VORGABEN
0:0 K_gr; A_id; G_b; Z_t
1:0 K_*; A_id; G_b; Z_t
2:0 K_*; A_*; G_b; Z_t
2:3 K_*; A_id; G_b; Z_m
3:3 K_*; A_id; G_b; Z_y
1:4 K_gr; A_*; G_b; Z_t
1:6 K_gr; A_id; G_*; Z_t
2:6 K_gr; A_id; G_*; Z_m
3:6 K_gr; A_id; G_*; Z_y
4:6 K_gr; A_id; G_*; Z_*
0:8 K_id; A_*; G_b; Z_t
1:8 K_id; A_*; G_*; Z_t
1:9 K_id; A_*; G_b; Z_m
2:9 K_id; A_*; G_b; Z_y
3:9 K_id; A_*; G_b; Z_*
0:10 K_id; A_id; G_*; Z_t
0:11 K_id; A_id; G_b; Z_m
1:11 K_id; A_id; G_b; Z_y
2:11 K_id; A_id; G_b; Z_*
count
1000
1000
1000
1000
1
10000
10000
10000
10000
10000
10000
10000
1000
1000
1000
10000
10000
10000
10000
Parameter
Spacemax
20000000
Timemax
25000000
Zeitkosten
1 bis 100000
Size per Tupel in Bytes:
500
New set on each iteration
4
Max Sets
40
- 229 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.14.2
LÖSUNG DER HEURISTIK
- 230 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.14.3
DETERMINISTISCHE LÖSUNG
7.9.3.14.4
VERGLEICH DER ERGEBNISSE
Parameter Heuristik
Deterministisch Abweichung
Kosten
1686650247
1686650247
0,00%
Space left
9990000
9990000
0,00%
Time left
24616192
24616192
0,00%
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte
den richtigen Wert im Lösungsweg 1.
- 231 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.15 VORGABEN UND ERGEBNISSE TEST 15
7.9.3.15.1
Required
Cubes:
1
2
3
4
5
6
7
8
9
10
11
7.9.3.15.2
VORGABEN
count
1:0 K_*; A_id; Z_t
3:0 K_*; A_*; Z_t
4:1 K_*; A_gr; Z_y
3:2 K_*; A_id; Z_y
4:3 K_gr; A_*; Z_y
2:4 K_gr; A_gr; Z_m
3:4 K_gr; A_gr; Z_y
2:6 K_id; A_*; Z_m
3:6 K_id; A_*; Z_y
1:7 K_id; A_gr; Z_m
2:8 K_id; A_id; Z_*
1
1000
10000
1000
1
1000
1
10000
1000
1
1
Parameter
Spacemax
58000000
Timemax
1500000
Zeitkosten
1 bis 100000
Size per Tupel in Bytes:
900
New set on each iteration
6
Max Sets
20
LÖSUNG DER HEURISTIK
- 232 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.15.3
DETERMINISTISCHE LÖSUNG
7.9.3.15.4
VERGLEICH DER ERGEBNISSE
Parameter Heuristik
Deterministisch Abweichung
Kosten
32747425
32747425
0,00%
Space left
9287500
9287500
0,00%
Time left
1291048
1291048
0,00%
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte
den richtigen Wert im Lösungsweg 3.
7.9.3.16 VORGABEN UND ERGEBNISSE TEST 16
7.9.3.16.1
Required
Cubes:
1
2
3
4
5
6
7
8
9
VORGABEN
count
4:3 K_*; G_l; A_gr; Z_t
3:6 K_*; G_b; A_gr; Z_t
4:9 K_*; G_bez; A_*; Z_m
2:12 K_gr; G_l; A_id; Z_t
3:19 K_gr; G_b; A_gr; Z_m
2:21 K_gr; G_bez; A_*; Z_t
1:24 K_id; G_l; A_id; Z_t
2:31 K_id; G_b; A_gr; Z_m
0:33 K_id; G_bez; A_gr; Z_t
1
1000
1000
10000
1
1000
10000
10000
10000
Parameter
Spacemax
8000000
Timemax
4000000
Zeitkosten
1 bis 100000
Size per Tupel in Bytes:
840
New set on each iteration
4
Max Sets
30
- 233 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.16.2
LÖSUNG DER HEURISTIK
- 234 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
- 235 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.16.3
DETERMINISTISCHE LÖSUNG
- 236 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.16.4
VERGLEICH DER ERGEBNISSE
Parameter Heuristik
Deterministisch Abweichung
Kosten
6198642
6198642
0,00%
Space left
3934362
3934362
0,00%
Time left
271760
271760
0,00%
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte
den richtigen Wert im Lösungsweg 1.
- 237 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.17 VORGABEN UND ERGEBNISSE TEST 17
7.9.3.17.1
Required
Cubes:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
VORGABEN
0:0 K_gr; A_id; G_b; Z_t
1:0 K_*; A_id; G_b; Z_t
2:0 K_*; A_*; G_b; Z_t
2:2 K_*; A_id; G_*; Z_t
2:3 K_*; A_id; G_b; Z_m
1:4 K_gr; A_*; G_b; Z_t
2:4 K_gr; A_*; G_*; Z_t
2:6 K_gr; A_id; G_*; Z_m
3:6 K_gr; A_id; G_*; Z_y
4:6 K_gr; A_id; G_*; Z_*
1:8 K_id; A_*; G_*; Z_t
2:8 K_id; A_*; G_*; Z_m
3:8 K_id; A_*; G_*; Z_y
4:8 K_id; A_*; G_*; Z_*
0:11 K_id; A_id; G_b; Z_m
1:11 K_id; A_id; G_b; Z_y
2:11 K_id; A_id; G_b; Z_*
count
10000
10000
10000
10000
10000
1
1
10000
10000
10000
10000
1000
1000
1000
10000
10000
10000
Parameter
Spacemax
50000000
Timemax
25000000
Zeitkosten
1 bis 100000
Size per Tupel in Bytes:
500
New set on each iteration
4
Max Sets
20
- 238 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.17.2
LÖSUNG DER HEURISTIK
- 239 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.17.3
DETERMINISTISCHE LÖSUNG
7.9.3.17.4
VERGLEICH DER ERGEBNISSE
Parameter Heuristik
Deterministisch Abweichung
Kosten
1067776407
1067776407
0,00%
Space left
14619500
14619500
0,00%
Time left
24903780
24903780
0,00%
Es konnte eine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte
den richtigen Wert im Lösungsweg 1.
- 240 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.18 VORGABEN UND ERGEBNISSE TEST 18
7.9.3.18.1
Required
Cubes:
1
2
3
4
5
6
7
7.9.3.18.2
VORGABEN
2:0 C_*; A_gr; T_d
3:1 C_*; A_gr; T_m
2:3 C_gr; A_*; T_d
3:3 C_gr; A_*; T_m
2:4 C_gr; A_gr; T_m
2:5 C_gr; A_id; T_y
1:6 C_id; A_*; T_d
count
10000
10000
10000
10000
10000
10000
10000
Parameter
New set on each iteration
2
Max Sets
50
average time to store a
tupel in time units
2
average time for io in time
units
2
average time for CPU
instructions in time units
0,002
max time
1500000
average time to query in
timeunits
100
average size of a tupel in
bytes
900
max space in bytes
58000000
time weight
75%
query weight
63%
LÖSUNG DER HEURISTIK
- 241 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
7.9.3.18.3
DETERMINISTISCHE LÖSUNG
7.9.3.18.4
VERGLEICH DER ERGEBNISSE
Parameter Heuristik
Deterministisch Abweichung
Kosten
1619,256708
1549,136539
-4,53%
Space left
2088400
2339500
10,73%
Time left
1016362,41
804498,9363
-26,33%
Es konnte keine eindeutige Übereinstimmung festgestellt werden. Die Heuristik lieferte
den Wert im Lösungsweg 4. Damit zeigt dieser Testlauf am deutlichsten die Grenzen
der Heuristik auf. Wäre in den Parameter die Anzahl der Lösungswege auf eine größere
Anzahl als 29 gesetzt worden, wäre das Ergebnis richtig.
8 CONCLUSIO
Das Ziel und die Vision, die am Beginn dieser Arbeit stand, war es eine Heuristik zu
entwickeln, welche die Auswahl der zu materialisieren Cubes treffen kann, diese zu
Testen, die Test zu analysieren und zu bewerten. Deshalb war die Arbeit eine von sehr
viel praktischer Programmiertätigkeit geprägte. Zusätzlich wurden jedoch in den
Kapiteln 1 bis 6 die methodischen und inhaltsbezogenen Grundlagen zum Abhandeln
der Arbeit gelegt. Dabei bin ich im Kapitel 1 speziell auf die Ziele, welche diese Arbeit
begründen, eingegangen. Im Kapitel 2 wurde dann auf die Datenmodellierung
eingegangen, da mit dem Aggregation Path Array eine Modellierungsmethode für
- 242 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Datawarehousesysteme als Werkzeug benutzt wird. Diese Modellierungsmethode wurde
im Kapitel 6 im Detail behandelt. Im Kapitel 3 wurde dann speziell auf Datenbanken
und SQL eingegangen, da im Prinzip ein Datawarehouse eine große Datenbank
darstellt. Kapitel 4 beschäftigt sich kurz mit ERP-Systemen im Allgemeinen, wobei ich
hier nicht in die Tiefe gegangen bin, da es für unsere Fragestellung grundsätzlich
unerheblich ist, woher die Daten stammen. Allerdings wird die von mir entwickelte
Software im Lehrbetrieb der Universität in Kombination mit einem ERP System
eingesetzt werden. Kapitel 5 geht im Speziellen auf das Datawarehouse ein. Das Kapitel
7 beschäftigt sich dann auf den eigentlichen Forschungsgegenstand. Dabei wird meine
Heuristik präsentiert, beschrieben und begründet. So wird insbesondere der Algorithmus
von Dijkstra verwendet, um eine Materialisierungsreihenfolge der Cubes zu finden. Zur
Bestimmung der deterministischen Lösung wurde ein Ansatz über die Permutation und
ein Ansatz über die Kombination in Verbindung mit Dijkstra vorgestellt. Beide liefern
das gleiche Ergebnis. Dabei hat die Kombination bei kleinen APAs
Geschwindigkeitsvorteile und die Permutation bei großen. Das Bestimmen der
deterministischen Lösungen hat sehr viel Rechenzeit in Anspruch genommen (ca 3 bis 4
Wochen pro Ergebnis). Durch den Einsatz von vier unterschiedlichen Rechnern wurde
versucht dieses Problem in den Griff zu bekommen und abschließend können nun
immerhin 18 Lösungen präsentiert werden. Die Ergebnisse, welche in Kapitel 7.9.2
aufgelistet sind brachten außergewöhnlich gute Ergebnisse. So konnte fast immer eine
100 % Übereinstimmung der heuristischen und deterministischen Lösung erreicht
werden. Allerdings konnte im Test 18 aufgezeigt werden, dass die Genauigkeit der
Heuristik von der Anzahl der Testläufe abhängt. Somit kann gezeigt werden, dass die
Genauigkeit der heuristischen Lösung durch den Benutzer einstellbar ist. Dabei besteht
ein Konflikt zwischen Berechnungszeit und Genauigkeit. Ausserdem muss beachtet
werden, dass nur kleine APAs mit relativ geringen Speicher- bzw. Zeitlimits getestet
wurden, um die Rechenzeit für die deterministische Lösung gering zu halten. Deshalb
wäre es interessant zusätzliche Testläufe in eine zukünftige Forschungsarbeit
einzubauen. Diesbezügliche Vorgespräche wurden mit Professor Prosser bereits geführt.
Der Zeitgewinn durch den Einsatz der Heuristik, welche bei den vorgestellten APAs
zwischen 2 und 30 Sekunden Berechnungszeit, im Vergleich zu 3 bis 4 Wochen
Berechnungszeit der deterministischen Lösung, benötigt, ist enorm. Das macht die
Heuristik für namhafte Softwarefirmen interessant. Deshalb wäre es in einem nächsten
Schritt sinnvoll die Heuristik mit dem Produkt eines Datenbankherstellers zu
kombinieren. Dabei könnte auch unmittelbar auf die Kostenfunktionen des Query
Optimizers des Herstellers zugegriffen werden. Dies wäre nach meiner Ansicht für den
praktischen Einsatz der Software jedenfalls notwendig.
- 243 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Zusätzlich zur rein wissenschaftlichen Arbeit wurde eine Softwareanwendung
entwickelt, welche didaktisch eingesetzt werden soll. Diese Anwendungen möchte ich
als höchste gelungen bezeichnen, da sie optimal für die Bedürfnisse der Studenten
maßgeschneidert wurde. Damit kann jeder Student in praktischer Tätigkeit die
Modellierung und die Entwicklung eines Datawarehouse vollziehen. Der Sourcecode
sowie die Hilfedatei im HTML Format befinden sich im Anhang und stellten einen
maßgeblichen Arbeitszeitanteil an dieser Arbeit dar.
9 LITERATUR
Achs, T. L., (2002), Erstellung eines Java-basierten Programms zur Implementierung
des Aggregationspfadarrays – Diplomarbeit an der Wirtschaftsuniversität Wien
Anahory, Sam, Murray, Dennis, (1997), Data Warehouse - Planung, Implementierung
und Administration, Addision-Wesley-Logman, Bonn; Reading, Massachusetts u.a..
Archilles, A., (2000), SQL – Standardisierte Datenbanksprache vom PC bis zum
Mainframe, 7. Aufl., Oldenbourg Wissenschaftsverlag GmbH, München
Baldi, St., (1999), Grundlagen der Wirtschaftsinformatik, 2. Aufl., Oldenbourg Verlag,
München
Barth, M., Karl, G., (2002), MySQL, DATA BECKER GmbH & Co. KG, Düsseldorf
Codd, E.F., (1970), A Relational Model of Data for Large Shared Data Banks“, CACM
Colby, L., Kawaguchi, A., Lieuwen, F., Mumick, I., Ross, K., (1997), Supporting
Multiple View Maintenance Policies, In: Joan Peckham (Ed.): SIGMOD 1997,
Proceedings ACM SIGMOD International Conference on Management of Data, May
13-15, 1997, Tucson, Arizona, USA. ACM Press 1997, SIGMOD Record 26(2), June
1997, S. 405 - 416
Connolly, T., Begg, C., Strachan, A., (2002), Datenbanksysteme, Addision-Wesely
Verlag, ein Imprint der Peason Education Deutschland GmbH, München
Cordts, S., (2002), Datenbankkonzepte in der Praxis, Addison-Wesley Verlag ein
Imprint der Pearson Education Deutschland GmbH, München
Crawley, P., Dilworth, R.P. (1973), Algebraic theory of lattice, Englewood Cliffs, New
Jersey
- 244 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Dippold, R., Meier, A., Ringgenberg, A., Schnider, W., Schwinn, K.,
Unternehmensweites Datenmanagement, (2001), 3. Aufl., Friedr. Vieweg & Sohn
Verlagsgesellschaft mbH, Braunschweig/Wiesbaden
Dunemann, O., (2002), Anfrageoptimierung für OLAP-Anwendungen in virtuellen Data
Warehouses, Tenea Verlag für Medien, Berlin
Džeroski, S., Lavrač, N., (2001), Relational Data Mining, Springer Verlag, Berlin et al.
Ehrenberg, D., Heine, P., (1998), Konzept zur Datenintegration für Management
Support Systeme auf der Basis uniformer Datenstrukturen, In: Wirtschaftsinformation
40. (1998), 6, S. 503-512
Falkowksi, B., (2002), Business Computing – Grundlagen und Standardsoftware,
Springer Verlag, Berlin u.a.
Fischer, J., Herold, W., Dangelmaier, W., Nastansky, L.; Suhl, L.; (2000), Bausteine der
Wirtschaftsinformatik, 2. Aufl., Erich Schmidt Verlag GmbH & Co., Berlin
Fritz, M., (1997), Data Warehouse Technologie, In: Datenbank-Management, InterestVerlag, Augsburg
Gabriel, R., Röhrs, H.P., (2003), Gestaltung und Einsatz von Datenbanksystemen,
Springer Verlag, Berlin et al.
Geppert, A., (2002), Objektrelationale und objektorientierte Datenbankkonzepte und –
systeme, dpunkt.verlag GmbH, Heidelberg
Golfarelli, M., Maio, D., Rizzi, S. (1998), Conceptual Design on data warehouses from
E/R Schemas; in: Proceeding of Hawaii International Conference On System Sciences,
January 6-9, 1998, Kona, Hawaii, ftp://ftp-db.deis.unibo.it/pub/hicss98.pdf (22.02.2001)
Goos, G., (2000), Vorlesungen über Informatik – Band 1, 3. Aufl., Springer-Verlag
Berlin, u.a.
Günther, H. O., Tempelmeier, H. (1997), Produktion und Logistik, 3. Aufl., SpringerVerlag, Berlin u.a.
Hansen, H.R., (1996), Wirtschaftsinformatik I; 7. Auflage, Lucius & Lucius, Stuttgart
Härder, T., Rahm, E., (2001), Datenbanksysteme, 2. Aufl., Springer-Verlag Berlin u.a.
- 245 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Harinarayan, V., Rajaraman, A., Ullmann, J.D., (1996), Implementing Data Cubes
Efficiently, In Proceedings of ACM SIGMOD Conference, Montreal, Canada, June
1996
Hartmut, E., (2000), Grundlagen und Konzepte der Informatik, 2. Aufl., Friedr. Vieweg
& Sohn Verlagsgesellschaft mbH, Braunschweig, Wiesbaden
Heinrich, L. J., (2002) Wirtschaftsinformatik, 2. Aufl., Oldenbourg Wissenschaftsverlag
GmbH, München
Houlette, F., (2002), SQL- IT Tutorial, mitp-Verlag, Bonn
Janko, W., H., (1998), Informationswirtschaft 1, 2. Aufl., Springer-Verlag, Berlin u.a.
Jianzhong, L., Doron, R., Jaideep, S., (1999), Aggregation Alogrithms for Very Large
Compressed Data Warehouses, In: Proceedings of the 25th Very Large Database
Conference, Edinburgh, Scotland, 1999, Morgan Kaufmann Publishers, Orlando
Kaiser, A. (2000), Skriptum zur Lehrveranstaltung Management und
Informationssysteme, Institut für Informationswirtschaft, http://exai3.wuwien.ac.at/~kaiser/mis/ (20.11.2000)
Kemper, A., Eickler, A., (1996), Datenbanksysteme – Eine Einführung, Oldenbourg
Verlag, München, Wien
Kemper, A., Eickler, A., (1999), Datenbanksysteme, 3. Aufl., Oldenbourg Verlag,
München
Kleinschmidt, P., Rank, C., (2002), Relationale Datenbanksysteme – Eine praktische
Einführung, 2. Aufl., Springer Verlag Berlin et al.
Labio, W. J., Zhuge, Y., Wiener, J.L., Gupta, H., Garcia-Molina, H., Widom, J., (1997),
The WHIPS Prototype for Data Warehous Creation and Maintenance, Joan Peckham
(Ed.): SIGMOD 1997, Proceedings ACM SIGMOD International Conference on
Management of Data, May 13-15, 1997, Tucson, Arizona, USA. ACM Press 1997,
SIGMOD Record 26(2), June 1997, S. 557 -559
Lusti, M. (1999), Data Warehousing und Data Mining, 1. Aufl., Springer-Verlag, Berlin
u.a.
Marsch, J., Fritze, J., (1999), Erfolgreiche Datenbankanwendung mit SQL, 5. Aufl.,
- 246 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Friedr. Vieweg & Sohn Verlagsgesellschaft mbH, Braunschweig, Wiesbaden
Martin, W. (1998), Data Warehousing, 1. Aufl., Internat. Thomson Publ., Bonn u.a.
Meier, A., (2001), Relationale Datenbanken, 4. Auflage, Springer-Verlag, Berlin u.a.
Mertens, P., Wieczorrek, H. W., (2000), Data X Strategien - Data Warehouse, Data
Mining und operationale Systeme für die Praxis, Springer-Verlag, Berlin u.a.
Morcinek, P., (2002), SQL, Data Becker GmbH & Co. KG, Düsseldorf
Müller-Angstenberger, J. W., (1994), Die Arbeitsweise des DB2-Optimizers, In:
Datenbank-Management, Interest-Verlag, Augsburg
Mumick, I., Quass, D., Mumick, B., (1997), Maintenance of Data Cubes and Summary
Tables in a Warehouse,In: Joan Peckham (Ed.): SIGMOD 1997, Proceedings ACM
SIGMOD International Conference on Management of Data, May 13-15, 1997, Tucson,
Arizona, USA. ACM Press 1997, SIGMOD Record 26(2), June 1997, S. 100 - 111
Panny, W., Taudes, A., (2000), Einführung in den Sprachkern von SQL-99, SpringerVerlag, Berlin u.a.
Pernul, G., Unland, R., (2001), Datenbanken im Unternehmen, Oldenbourg
Wissenschaftsverlag GmbH, München, Wien
Prosser, A., Ossimitz, M. L., (2000a), Analytical Logistics Information System SAP
BW – Teaching Material for the Department of Production Management ), WS 00/01,
Prosser, A., Ossimitz, M. L., (2000b), Eine Methode zur konzeptionellen Modellierung
multidimensionaler Datenstrukturen im Data Warehouse (Handout)
Prosser, A., Ossimitz, M. L., (2001), Data Warehouse Management – Using SAP BW,
Facultas Verlags- und Buchhandels AG, Wien
Prosser, A., Ossimitz, M. L., (2002), Data Warehouse Management – Teaching Material
for the Department of Production Management ), WS 02/03,
Rautenstrauch, C., Schulze, T., (2003), Informatik für Wirtschaftswissenschaftler und
Wirtschaftsinformatiker, Springer-Verlag Berlin u.a.
Redaktion Toolbox, (2002), Datenbanken mit Delphi, C&L Computer und
Literaturverlag, Böblingen
- 247 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Reß, H., Viebeck, G., (2000), Datenstrukturen und Algorithmen, Carl Hanser Verlag,
München, Wien
Riordan, R. M., (2000), Microsoft SQL Server 2000 Programmierung, Microsoft Press
Deutschland, Unterschleißheim
Saake, G., Sattler, K., (2002), Algorithmen & Datenstrukturen – Eine Einführung mit
Java, dpunkt.verlag GmbH, Heidelberg
Schicker, E., (1999), Datenbanken und SQL, 2. Aufl., B.G. Teuber, Stuttgart, Leibzig
Schneider, U., Werner, D., (2000), Taschenbuch der Informatik, 3. Aufl., Carl Hanser
Verlag, München, Wien
Sedgewick, R., (2002), Algorithmen, 2. Aufl., Addison-Wesley, München et al.
Seemann, A., Schmalzridt, B., Lehmann, P., (2001), SAP Business Information
Warehouse, Galileo Press, Bonn
Shaw, M.; Blanning, R., Strader, T., Whinston, A., (2000), Handbook on electronic
commerce, Springer-Verlag Berlin u.a.
Stock, W., (2000), Informationswirtschaft, Oldenburg Wissenschaftsverlag GmbH,
München
Taylor, G. A., (2001), SQL für Dummies, 2. Aufl., mitp-Verlag ein Geschäftsbereich
der verlag moderne industrie Buch AG & Co. KG, Landsberg
Vossen, G., (2000), Datenmodelle, Datenbanksprachen und
Datenbankmanagementsysteme, 4. Aufl., Oldenbourg Verlag, München, Wien
Widenius, M., Axmark, D., (2002), MySQL- Das offizielle Handbuch, Die Deutsche
Bibliothek
Witt, K., (2001), Algebraische Grundlagen der Informatik – Zahlen –Strukturen –
Codierung – Verschlüsselung, Friedr. Vieweg & Sohn Verlagsgesellschaft mbH,
Braunschweig / Wiesbaden
Witten, I.H., Eibe, F., (2000), Data mining: practical machine learning tools and
techniques with Java implementations, Morgan Kaufmann Publishers, San Francisco
Yang, J., Karlapalem, K., Li, Q., (1997), Algorithms for Materialized View Design in
- 248 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Data Warehousing Environment, In: Proceedings of the 23rd VLDB Conference
Athens, Greece ftp://www.vldb.org/conf/1997/P136.PDF (22.02.2001)
- 249 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
10 ABBILDUNGSVERZEICHNIS
Abbildung 1: Symbol für Entitätstyp.............................................................................. 18
Abbildung 2: Super- und Subentitätstypen mit „is a“ Operator [Quelle:
Rautenstrauch/Schulze (2003) S. 237].................................................................... 19
Abbildung 3: Entitätsmenge mit Attributen.................................................................... 19
Abbildung 4: Einfaches Symbol eines Beziehungstyps für einfache Darstellbarkeit .... 20
Abbildung 5: Formal richtiges Beziehungssymbol der ER-Modell Konvention ........... 20
Abbildung 6: 1:1 Beziehung zwischen Kunde und Hauptwohnsitz ............................... 21
Abbildung 7: 1:n Beziehung zwischen Abteilung und Mitarbeiter ................................ 22
Abbildung 8: m:n Beziehung zwischen Mitarbeiter und Projekt ................................... 22
Abbildung 9: Rekursiver Beziehungstyp [Quelle: Rautenstrauch/Schulze (2003) S. 237]
................................................................................................................................ 23
Abbildung 10: Firmenhierarchie..................................................................................... 24
Abbildung 11: Beispielhafte Umsetzung einer 1:1 Beziehung in das Realtionenmodell
in der vereinfachten Darstellung der Beziehung [Quelle: Baldi (1999), S. 84 ]..... 29
Abbildung 12: Beispielhafte Umsetzung einer 1:n Beziehung in das Relationenmodell
in der vereinfachten Darstellung der Beziehung [Quelle: Baldi (1999), S. 84]...... 30
Abbildung 13: Beispielhafte Umsetzung einer m:n Beziehung in das Relationenmodell
in der vereinfachten Darstellung der Beziehung [Quelle: Baldi (1999), S. 84 ]..... 31
Abbildung 14: Relationale Datenstruktur [in Anlehnung: Panny/Taudes (2000) S. 23] 37
Abbildung 15: Die Architektur eine Data Warehouse [Quelle: in Anlehnung an
Posser/Ossimitz (2001) S. 26] ................................................................................ 49
Abbildung 16: Die Basisarchitektur des WHIPS Systems [Quelle: Labio et al. (1997) S.
557] ......................................................................................................................... 56
Abbildung 17: Die WHIPS System Architektur für Warehouse Maintenance [Quelle:
Labio et at (1997) S. 558] ....................................................................................... 57
Abbildung 18: Das Modellsystem [Quelle: Kaiser (2000)]............................................ 67
Abbildung 19: Phasen der Modellierung [Quelle: Kaiser (2000)] ................................. 68
Abbildung 20: Einfache Hierarchie am Beispiel eines Kunden ..................................... 69
Abbildung 21: Darstellung eines Würfels (cube) mit den Dimensionen Zeit, Artikel und
Kunden [ in Anlehnung: Prosser/Ossimitz (2000), S. 18] ...................................... 70
- 250 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 22: Selektion der Daten durch das Slice-Verfahren [Quelle: Schinzer et al.
(1997), S. 40] .......................................................................................................... 71
Abbildung 23: Die Navigation durch die Navigationsebenen [in Anlehnung: Prosser,
Ossimitz (2000 a), S. 24 ] ....................................................................................... 72
Abbildung 24: Einfaches Modell eines dreidimensionalen „Fact-Schema“ [in
Anlehnung: Prosser, Ossimitz, (2000 a), S. 29]...................................................... 73
Abbildung 25: Attributsbaum vor Pruning und Grafting [in Anlehnung: Prosser,
Ossimitz, (2000 a), S. 33] ....................................................................................... 74
Abbildung 26: Attributsbaum nach Pruning und Grafting [in Anlehnung: Prosser,
Ossimitz, (2000 a), S. 34] ....................................................................................... 74
Abbildung 27: Gitter [in Anlehnung: Prosser, Ossimitz (2000 a), S. 40]....................... 75
Abbildung 28: Star-Schema mit „Fact-Table“ (gelb) und vier Dimension-Tables [In
Anlehnung: Prosser, Ossimitz (2000 a), S. 51]....................................................... 77
Abbildung 29: Das klassische Star-Schema [In Anlehnung: Prosser/Ossimitz (2000a ) S.
51] ........................................................................................................................... 78
Abbildung 30: Das Fact Constellation-Schema [Quelle: Prosser/Ossimitz (2001) S. 76]
................................................................................................................................ 79
Abbildung 31: Snowflake-Schema mit Attribut-Tables [in Anlehnung: Prosser,
Ossimitz (2000a), S. 62] ......................................................................................... 80
Abbildung 32: Galaxy-Schema und Multitube-Architektur [Quelle:
Rautenstrauch/Schulze (2003) S. 334].................................................................... 81
Abbildung 33: Das Unimu-Schema [Quelle: Ehrenberg/Heine (1998) S. 507] ............. 82
Abbildung 34: Darstellung des APA des Praxisbeispiels in Kurznotation (links) und mit
Attributsnamen (rechts) nicht redundanzfrei [in Anlehnung: Prosser, Ossimitz,
(2000 a), S. 43] ...................................................................................................... 83
Abbildung 35: Darstellung des APA des Praxisbeispiels in Kurznotation (links) und mit
Attributsnamen (rechts) redundanzfreie Menge farblich markiert [in Anlehnung:
Prosser, Ossimitz (2000 a), S. 43] ......................................................................... 86
Abbildung 36: Darstellung der interessanten Würfel [in Anlehnung: Prosser, Ossimitz
(2000 b), S. 17 ] ...................................................................................................... 87
Abbildung 37: Anzeigebeispiel der Derivative (Bereich x) des Würfels x [in Anlehnung:
Prosser, Ossimitz (2000 b), S. 17] .......................................................................... 89
- 251 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 38: Anzeigebeispiel der Derivate (Bereich y) des Würfels y [in Anlehnung:
Prosser, Ossimitz (2000 b), S. 17] .......................................................................... 89
Abbildung 39: Anzeigebeispiel der Derivate (Bereich x + y) der Würfels x und y [in
Anlehnung: Prosser, Ossimitz (2000 b), S. 17] ...................................................... 90
Abbildung 40: Abgrenzung der Phasen der Betrachtung ............................................... 93
Abbildung 41: Graph mit zwei Knoten........................................................................... 95
Abbildung 42: Bewerteter Graph [Quelle: Reß/Viebock (2000) S. 404] ....................... 98
Abbildung 43: Darstellung der Knoten und Kanten ..................................................... 107
Abbildung 44: Funktionsweise eines Kostenmodells [Quelle: Kemper/Eickler (1996) S.
212] ....................................................................................................................... 109
Abbildung 45: Beispielhafte Arbeitsabfolge im G-Algorithmus [Quelle: Jianzhong
(1999) S. 654] ....................................................................................................... 114
Abbildung 46: Schematische Aufstellung der Würfel und Kostenfunktionen ............. 122
Abbildung 47: Dimensionen und Hierarchien des DemoAPA..................................... 135
Abbildung 48: DemoAPA mit Lösung ......................................................................... 135
Abbildung 49: Schritt 1 der Heuristik nach Thomas ACHS ........................................ 136
Abbildung 50: Schritt 2 der Heuristik nach Thomas ACHS ........................................ 137
Abbildung 51: Schritt 3 der Heuristik nach Thomas ACHS ........................................ 137
Abbildung 52: Schritt 4 der Heuristik nach Thomas ACHS ........................................ 138
Abbildung 53: Schritt 5 der Heuristik nach Thomas ACHS ........................................ 138
Abbildung 54: Schritt 6 der Heuristik nach Thomas ACHS ........................................ 139
Abbildung 55: Schritt 7 der Heuristik nach Thomas ACHS ........................................ 139
Abbildung 56: Schritt 8 der Heuristik nach Thomas ACHS ........................................ 140
Abbildung 57: Schritt 9 der Heuristik nach Thomas ACHS ........................................ 140
Abbildung 58: Schritt 10 der Heuristik nach Thomas ACHS ...................................... 141
Abbildung 59: Schritt 11 der Heuristik nach Thomas ACHS ...................................... 141
Abbildung 60: Schritt 12 der Heuristik nach Thomas ACHS ...................................... 142
Abbildung 61: Schritt 13 der Heuristik nach Thomas ACHS ...................................... 142
Abbildung 62: Schritt 14 der Heuristik nach Thomas ACHS ...................................... 143
Abbildung 63: Schritt 15 der Heuristik nach Thomas ACHS ...................................... 143
- 252 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Abbildung 64: Schritt 95 der Heuristik nach Thomas ACHS ...................................... 144
Abbildung 65: Schritt 96 der Heuristik nach Thomas ACHS ...................................... 144
Abbildung 66: Schritt 97 der Heuristik nach Thomas ACHS ...................................... 145
Abbildung 67: Schritt 98 der Heuristik nach Thomas ACHS ...................................... 146
Abbildung 68: Schritt 99 der Heuristik nach Thomas ACHS ...................................... 146
Abbildung 69: Das Hauptmenu des APA Programmes................................................ 166
Abbildung 70: Der APA Input Screen.......................................................................... 167
Abbildung 71: Die Präsentationsmaske des APA Grid ................................................ 168
Abbildung 72: Die Auswahlmaske der Required Cubes .............................................. 169
Abbildung 73: ER-Diagramm für die APA Datenbank................................................ 171
Abbildung 74: Ableitung des APA Relationenmodells aus dem APA ER-Modell...... 175
Abbildung 75: Der Aufbau eines Star Schemas als Basis der CREATE TABLE
Anweisungen ........................................................................................................ 185
Abbildung 76: Beispielhafte Auflistung der Dimension Tables und der Fact Tables beim
Fact Constellation-Schema ................................................................................... 187
Abbildung 77: Input Screen des Demo APA................................................................ 188
Abbildung 78: APA Grid Screen des Demo APA........................................................ 189
Abbildung 79: Demonstrative Anzeigen der Possible Cubes....................................... 202
- 253 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
11 TABELLENVERZEICHNIS
Tabelle 1: Kombinationen von Grad und Ausprägung................................................... 21
Tabelle 2: Gegenüberstellung von relationalen und SQL-Ausdrücken [Quelle:
Pernul/Unland (2001) S. 263]................................................................................. 35
Tabelle 3: Vergleich operative Daten und Data Warehouse [in Anlehnung: Connolly et
al. (2002) S. 910; Prosser, Ossimitz (2000 a), S. 11].............................................. 54
Tabelle 4: Änderungen der Aggregate nach Funktionen [Quelle: Mumick et al. (1997)
S.105]...................................................................................................................... 59
Tabelle 5: Informationsflüsse im Data Warehouse [Quelle: Connolly et al. (2002) S.
918ff] ...................................................................................................................... 60
Tabelle 6: Operatoren und Zahlentypen [in Anlehnung: Prosser, Ossimitz (2000 a), S.
20] ........................................................................................................................... 70
Tabelle 7: Berechnung der kürzesten Wege von einem Knoten in einem Graph zu allen
anderen [Quelle: Reß/Viebeck (2000) S. 405]........................................................ 99
Tabelle 8: Berechnung der kürzesten Wege für einen azyklischen Graphen [Quelle:
Reß/Viebeck (2000) S. 408] ................................................................................. 104
Tabelle 9: Entwicklung der Query Response Time im Verhältnis zur Size [Quelle:
Harinarayan et al. (1996) S. 11]............................................................................ 111
Tabelle 10: : Beschreibung der Tables der APA Datenbank ........................................ 174
Tabelle 11: Beispielhafter BFT für die Anwendung .................................................... 185
Tabelle 12: Beispielhafter Customer-Dimensionstable für die Anwendung ................ 186
Tabelle 13: Beispielhafter Items-Dimensionstable für die Anwendung....................... 186
Tabelle 14: Beispielhafter Time-Dimensionstable für die Anwendung ....................... 186
- 254 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
12 ANHANG
12.1 QUELLCODE DER ANWENDUNG
12.1.1
PROGRAMM QUELLCODE APAWIN
program APAWin;
uses
Forms,
APA_Applicationunit in '..\Units\APA_Applicationunit.pas' {APA_Application},
APA_Gridunit in '..\Units\APA_Gridunit.pas' {APA_Grid},
APA_Input_Dimensionunit in '..\Units\APA_Input_Dimensionunit.pas'
{APA_Insert_Dimension},
APA_Input_Hierarchyunit in '..\Units\APA_Input_Hierarchyunit.pas'
{APA_Insert_Hierarchy},
APA_Input_Reqblockunit in '..\Units\APA_Input_Reqblockunit.pas' {APA_Insert_Reqblock},
APA_Input_Screenunit in '..\Units\APA_Input_Screenunit.pas' {APA_Input_Screen},
APA_Keyunit in '..\Units\APA_Keyunit.pas' {APA_Insert_Key},
APA_Optionsunit in '..\Units\APA_Optionsunit.pas' {APA_Options},
APA_Parameterunit in '..\Units\APA_Parameterunit.pas' {APA_Parameter},
APA_Selectionunit in '..\Units\APA_Selectionunit.pas' {APA_Selection_Screen},
APA_Analyseunit in '..\Units\APA_Analyseunit.pas' {APA_Analyse},
APA_Screenunit in '..\Units\APA_Screenunit.pas' {APA_Screen},
APA_Show_costsunit in '..\Units\APA_Show_costsunit.pas' {APA_Showcosts},
APA_Processunit in '..\Units\APA_Processunit.pas' {APA_Show_Process},
APA_Sqlunit in '..\Units\APA_Sqlunit.pas' {APA_Sql},
APA_Dialogunit in '..\Units\APA_Dialogunit.pas' {APA_Dialog},
APA_Helpunit in '..\Units\APA_Helpunit.pas' {APA_Help};
{$R *.res}
begin
Application.Initialize;
Application.Title := 'APA Application';
Application.CreateForm(TAPA_Screen, APA_Screen);
Application.CreateForm(TAPA_Application, APA_Application);
Application.CreateForm(TAPA_Grid, APA_Grid);
Application.CreateForm(TAPA_Insert_Dimension, APA_Insert_Dimension);
Application.CreateForm(TAPA_Insert_Hierarchy, APA_Insert_Hierarchy);
Application.CreateForm(TAPA_Insert_Reqblock, APA_Insert_Reqblock);
Application.CreateForm(TAPA_Input_Screen, APA_Input_Screen);
Application.CreateForm(TAPA_Insert_Key, APA_Insert_Key);
Application.CreateForm(TAPA_Options, APA_Options);
Application.CreateForm(TAPA_Parameter, APA_Parameter);
Application.CreateForm(TAPA_Selection_Screen, APA_Selection_Screen);
Application.CreateForm(TAPA_Analyse, APA_Analyse);
Application.CreateForm(TAPA_Showcosts, APA_Showcosts);
Application.CreateForm(TAPA_Show_Process, APA_Show_Process);
Application.CreateForm(TAPA_Sql, APA_Sql);
Application.CreateForm(TAPA_Dialog, APA_Dialog);
Application.CreateForm(TAPA_Help, APA_Help);
Application.Run;
end.
12.1.2
UNIT APA_ANALYSEUNIT.DFM
object APA_Analyse: TAPA_Analyse
Left = 220
Top = 114
Width = 696
Height = 480
Caption = 'APA_Analyse'
Color = clBtnFace
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
- 255 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Font.Height = -11
Font.Name = 'MS Sans Serif'
Font.Style = []
OldCreateOrder = False
Position = poScreenCenter
OnShow = FormShow
PixelsPerInch = 96
TextHeight = 13
object Analysetext: TMemo
Left = 0
Top = 0
Width = 688
Height = 405
Align = alClient
ScrollBars = ssBoth
TabOrder = 0
end
object Panel1: TPanel
Left = 0
Top = 405
Width = 688
Height = 41
Align = alBottom
TabOrder = 1
object Button_Close: TButton
Left = 16
Top = 8
Width = 75
Height = 25
Cancel = True
Caption = 'Close'
Default = True
TabOrder = 0
OnClick = Button_CloseClick
end
end
end
12.1.3
UNIT APA_ANALYSEUNIT.PAS
unit APA_Analyseunit;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, ExtCtrls;
type
TAPA_Analyse = class(TForm)
Analysetext: TMemo;
Panel1: TPanel;
Button_Close: TButton;
procedure FormShow(Sender: TObject);
procedure Button_CloseClick(Sender: TObject);
private
{ Private-Deklarationen }
public
{ Public-Deklarationen }
end;
var
APA_Analyse: TAPA_Analyse;
implementation
uses APA_Gridunit, APA_Parameterunit, APA_Applicationunit;
{$R *.dfm}
procedure TAPA_Analyse.FormShow(Sender: TObject);
var counter, counter2,pos:longint;
- 256 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
var anztupels:Int64;
var anzrequired, anzmat:longint;
var Countergebnisse,N,K,NK:Extended;
var anznotredundant:longint;
var aktzeile,aktspalte,count_of_derivates:longint;
var derivspalte,derivzeile,possiblecubes:longint;
begin
//Anzeige der Analyse des BFT
Analysetext.Lines.Clear;
Analysetext.Lines.Add('Analysis of Base Fact Table (BFT):');
Analysetext.Lines.Add('==================================');
Analysetext.Lines.Add('');
//Berechnen der Tupels im BFT table
anztupels:=0;anzmat:=0;anzrequired:=0;anznotredundant:=0;
for counter:=0 to anzd-1 do begin;
anztupels:=anztupels+countdaten[counter,0];
end;
Analysetext.Lines.Add('Tupels from source: '+inttostr(anztupels));
Analysetext.Lines.Add('');
Analysetext.Lines.Add('List of Required cubes:');
Analysetext.Lines.Add('===========================');
for counter:=0 to anzzeilen-1 do begin
for counter2:=0 to anzspalten-1 do begin
if APA[counter2,counter].farbe=clYellow then begin
anznotredundant:=anznotredundant+1;
end;
if APA[counter2,counter].interessant=true then begin
anzrequired:=anzrequired+1;
Analysetext.Lines.Add('Required cube: '+inttostr(counter2)+':'+inttostr(counter)+'
'+APA[counter2,counter].kurzbez);
end;
end;
end;
Analysetext.Lines.Add('found '+inttostr(anzrequired)+' required cubes in
'+inttostr(anznotredundant)+' not redundant cubes.');
Analysetext.Lines.Add('');
Analysetext.Lines.Add('List of Materialized cubes:');
Analysetext.Lines.Add('===========================');
for counter:=0 to anzzeilen-1 do begin
for counter2:=0 to anzspalten-1 do begin
if APA[counter2,counter].materalisieren=true then begin
anzmat:=anzmat+1;
Analysetext.Lines.Add('Materialized cube:
'+inttostr(counter2)+':'+inttostr(counter)+' '+APA[counter2,counter].kurzbez);
end;
end;
end;
Analysetext.Lines.Add('found '+inttostr(anzmat)+' materialized cubes');
Analysetext.Lines.Add('');
Analysetext.Lines.Add('Deterministic solution:');
Analysetext.Lines.Add('===========================');
assignfile(fCountermerk,'C:\APADIR\DATA\Countermerk.dat');
{$i-}
reset(fCountermerk);
{$i+}
if ioresult<>0 then showmessage('Can not open File Countermerk.dat');
assignfile(fCubes,'C:\APADIR\DATA\Cubes.dat');
{$i-}
reset(fCubes);
{$i+}
if ioresult<>0 then showmessage('Can not open File Cubes.dat');
assignfile(fMerkkosten,'C:\APADIR\DATA\Merkkosten.dat');
{$i-}
- 257 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
reset(fMerkkosten);
{$i+}
if ioresult<>0 then showmessage('Can not open File Merkkosten.dat');
try
pos:=0;
repeat;
if (filesize(fCountermerk)>0) then begin;
seek(fCountermerk,pos);
read(fCountermerk,vCountermerk);
seek(fCubes,round(vCountermerk.nr)-1);
read(fCubes,vCubes);
Analysetext.Lines.Add('Cube('+floattostr(vCountermerk.Lfnr)+'):'+floattostr(vCount
ermerk.Nr)+' = ('
+inttostr(vCubes.Spalte)+':'+inttostr(vCubes.Zeile)+')');
end;
pos:=pos+1;
until pos>=filesize(fCountermerk);;
if (filesize(fMerkkosten)>0) then
begin;
Analysetext.Lines.Add('');
seek(fMerkkosten,0);
read(fMerkkosten,vMerkkosten);
Analysetext.Lines.Add('Costs: '+floattostr(vMerkkosten.Kosten));
seek(fMerkkosten,1);
read(fMerkkosten,vMerkkosten);
Analysetext.Lines.Add('Space left: '+floattostr(vMerkkosten.Kosten));
seek(fMerkkosten,2);
read(fMerkkosten,vMerkkosten);
Analysetext.Lines.Add('Time left: '+floattostr(vMerkkosten.Kosten));
end;
Analysetext.Lines.Add('');
Analysetext.Lines.Add('Count of possible solution:');
Analysetext.Lines.Add('===========================');
{Berechne Possible Cubes}
counter:=anzrequired;
{1.b Setze Derivate zu}
for aktzeile:=0 to anzzeilen-1 do begin
for aktspalte:=0 to anzspalten-1 do begin
if
(APA[aktspalte,aktzeile].farbe=clYellow)and(APA[aktspalte,aktzeile].interessant=fa
lse) then begin
count_of_derivates:=0;
for derivspalte:=0 to anzspalten-1 do begin;
for derivzeile:=0 to anzzeilen-1 do begin;
if (APA[derivspalte,derivzeile].interessant=true)and
(APA[derivspalte,derivzeile].farbe=clYellow) then begin
if APA_Grid.isderivat(aktspalte,aktzeile,derivspalte,derivzeile) then begin
//Jetzt kontrollieren wir, ob dieser Würfel auch noch ein Derivat eines
anderen Würfels
count_of_derivates:=count_of_derivates+1;
end;//Ende von derivat
end;//Ende von interessant
end;//of derivzeile
end;//of derivsspalte
- 258 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if count_of_derivates>=1 then begin
Analysetext.Lines.Add('Possible cube:
'+inttostr(aktspalte)+':'+inttostr(aktzeile)+' '+APA[aktspalte,aktzeile].kurzbez);
counter:=counter+1;
end;
end//von Yellow
else if
(APA[aktspalte,aktzeile].farbe=clYellow)and(APA[aktspalte,aktzeile].interessant=tr
ue) then
Analysetext.Lines.Add('Possible and Required cube:
'+inttostr(aktspalte)+':'+inttostr(aktzeile)+' '+APA[aktspalte,aktzeile].kurzbez);
end;//aktspalte
end;//aktzeile
possiblecubes:=counter;
Analysetext.Lines.Add('Found '+inttostr(possiblecubes)+' Possible Cubes');
{Berechne Permutation}
Countergebnisse:=0;
N:=1;
for counter2:=1 to possiblecubes do N:=N*counter2;
Analysetext.Lines.Add('Possible Combinations Permutation: '+floattostr(N));
for counter:=1 to possiblecubes do begin
K:=1;
for counter2:=1 to counter do K:=K*counter2; //K!
NK:=1;
for counter2:=1 to (possiblecubes-counter) do NK:=NK*counter2;
Countergebnisse:=Countergebnisse+(N/(K*NK));
end;
Analysetext.Lines.Add('Possible Combinations Kombination:
'+floattostr(Countergebnisse));
finally
CloseFile(fcountermerk);
CloseFile(fMerkkosten);
CloseFile(fCubes);
end;
end;
procedure TAPA_Analyse.Button_CloseClick(Sender: TObject);
begin
Close;
end;
end.
12.1.4
UNIT APA_APPLICATIONUNIT.DFM
object APA_Application: TAPA_Application
Left = 158
Top = 115
ActiveControl = APA_Input_Screen_button
BorderStyle = bsSingle
Caption = 'APA Application'
ClientHeight = 522
ClientWidth = 704
Color = clBtnFace
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -11
Font.Name = 'MS Sans Serif'
Font.Style = []
Menu = APA_Menu
OldCreateOrder = False
Position = poScreenCenter
OnActivate = FormActivate
OnCloseQuery = FormCloseQuery
- 259 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
PixelsPerInch = 96
TextHeight = 13
object Image1: TImage
Left = 0
Top = 0
Width = 704
Height = 522
Align = alClient
Picture.Data = {
07544269746D61702EEB1000424D2EEB1000000000003600000028000000C302
00000A0200000100180000000000F8EA1000C30E0000C30E0000000000000000
. . . . .
. . . . .
. . . . .
5E4C5A5E4C5A5E4C5A5E4C5A5E4D5A5E4D5A5E4D5A5E4D5A5E4D5A5E4D5A5E4D
5A5E4D5A5E4E5A5E4E5A5E4E5A5E4E5B5E4E5B5E6E7C80000000}
end
object APA_Input_Screen_button: TButton
Left = 40
Top = 152
Width = 75
Height = 25
Caption = 'Input Screen'
TabOrder = 0
OnClick = APA_Input_Screen_buttonClick
end
object APA_Grid_button: TButton
Left = 40
Top = 408
Width = 75
Height = 25
Caption = 'APA Grid'
TabOrder = 1
OnClick = APA_Grid_buttonClick
end
object Button_Apa_Selection: TButton
Left = 328
Top = 280
Width = 123
Height = 25
Caption = 'APA Selection Screen'
TabOrder = 2
OnClick = Button_Apa_SelectionClick
end
object APA_Menu: TMainMenu
Left = 528
Top = 8
object File1: TMenuItem
Caption = 'File'
object Open1: TMenuItem
Caption = 'Open'
OnClick = Open1Click
end
object Save1: TMenuItem
Caption = 'Save'
OnClick = Save1Click
end
object Saveas1: TMenuItem
Caption = 'Save as ...'
OnClick = Saveas1Click
end
object Exit1: TMenuItem
Caption = 'Exit'
OnClick = Exit1Click
end
end
object Screens1: TMenuItem
Caption = 'Screens'
object InputScreen1: TMenuItem
Caption = 'Input Screen'
OnClick = InputScreen1Click
end
object APAGridScreen1: TMenuItem
Caption = 'APA Grid Screen'
- 260 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
OnClick = APAGridScreen1Click
end
object APASelectionScreen1: TMenuItem
Caption = 'APA Selection Screen'
OnClick = APASelectionScreen1Click
end
end
object Berechnungen1: TMenuItem
Caption = 'Random costs'
object GeneriereZufallskosten1: TMenuItem
Caption = 'Build random costs'
OnClick = GeneriereZufallskosten1Click
end
object ShowRandomCosts1: TMenuItem
Caption = 'Show random costs'
OnClick = ShowRandomCosts1Click
end
object Restrictedcosts1: TMenuItem
AutoCheck = True
Caption = 'Restricted costs'
Checked = True
OnClick = Restrictedcosts1Click
end
end
object Analyse1: TMenuItem
Caption = 'Analyse'
object AnalyseAPA1: TMenuItem
Caption = 'Analyse APA'
OnClick = AnalyseAPA1Click
end
end
object Settings1: TMenuItem
Caption = 'Settings'
object Parameter1: TMenuItem
Caption = 'Parameters'
OnClick = Parameter1Click
end
object Options1: TMenuItem
Caption = 'Options'
OnClick = Options1Click
end
end
object Help1: TMenuItem
Caption = 'Help'
object HelpfilesAPAprogram1: TMenuItem
Caption = 'Help files APA program'
OnClick = HelpfilesAPAprogram1Click
end
object HelpfilesforMainmenu1: TMenuItem
Caption = 'Help files for Main menu'
OnClick = HelpfilesforMainmenu1Click
end
end
end
object APASavedialog: TSaveDialog
DefaultExt = 'apa'
Filter = 'APA File|*.apa'
InitialDir = 'c:\APADIR\Save'
Left = 272
Top = 168
end
object APAOpendialog: TOpenDialog
DefaultExt = 'apa'
Filter = 'APA File|*.apa'
InitialDir = 'c:\APADIR\Save'
Left = 368
Top = 120
end
end
- 261 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
12.1.5
UNIT APA_APPLICATIONUNIT.PAS
unit APA_Applicationunit;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, Menus, StdCtrls, ExtCtrls, Math, ComCtrls, ShellCtrls;
type Countertype=
record
Lfnr:Extended;
Nr:Extended;
end;
type Cubestype=
record
Lfnr:Extended;
Spalte:Longint;
Zeile:Longint;
Required:Longint;
end;
type Kostentype=
record
VonSpalte:Longint;
VonZeile:Longint;
ZuSpalte:Longint;
ZuZeile:Longint;
Query:Extended;
Build:Extended;
end;
type Merkkostentype=
record
Lfnr:Extended;
Kosten:Extended;
end;
type ReqCubestype=
record
Lfnr:Extended;
Spalte:Longint;
Zeile:Longint;
end;
type
TAPA_Application = class(TForm)
APA_Menu: TMainMenu;
File1: TMenuItem;
Open1: TMenuItem;
Save1: TMenuItem;
Saveas1: TMenuItem;
Exit1: TMenuItem;
Screens1: TMenuItem;
InputScreen1: TMenuItem;
APAGridScreen1: TMenuItem;
APASelectionScreen1: TMenuItem;
Berechnungen1: TMenuItem;
Settings1: TMenuItem;
Parameter1: TMenuItem;
Options1: TMenuItem;
Image1: TImage;
APA_Input_Screen_button: TButton;
APA_Grid_button: TButton;
Button_Apa_Selection: TButton;
APASavedialog: TSaveDialog;
APAOpendialog: TOpenDialog;
GeneriereZufallskosten1: TMenuItem;
ShowRandomCosts1: TMenuItem;
Restrictedcosts1: TMenuItem;
Analyse1: TMenuItem;
- 262 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
AnalyseAPA1: TMenuItem;
Help1: TMenuItem;
HelpfilesAPAprogram1: TMenuItem;
HelpfilesforMainmenu1: TMenuItem;
Shelldir: TShellTreeView;
procedure Kostensortieren();
function findkosten(vonspalte,vonzeile,zuspalte,zuzeile:longint):boolean;
procedure Parameter1Click(Sender: TObject);
procedure Lade(Filename:string);
procedure Open1Click(Sender: TObject);
procedure Speichern(Filename:string);
procedure Saveas1Click(Sender: TObject);
procedure Exit1Click(Sender: TObject);
procedure InputScreen1Click(Sender: TObject);
procedure APAGridScreen1Click(Sender: TObject);
procedure APASelectionScreen1Click(Sender: TObject);
procedure Options1Click(Sender: TObject);
procedure APA_Input_Screen_buttonClick(Sender: TObject);
procedure APA_Grid_buttonClick(Sender: TObject);
procedure Button_Apa_SelectionClick(Sender: TObject);
procedure FormActivate(Sender: TObject);
procedure GeneriereZufallskosten1Click(Sender: TObject);
procedure ShowRandomCosts1Click(Sender: TObject);
procedure Save1Click(Sender: TObject);
procedure FormCloseQuery(Sender: TObject; var CanClose: Boolean);
procedure Restrictedcosts1Click(Sender: TObject);
procedure AnalyseAPA1Click(Sender: TObject);
procedure HelpfilesAPAprogram1Click(Sender: TObject);
procedure HelpfilesforMainmenu1Click(Sender: TObject);
procedure FormCreate(Sender: TObject);
private
{ Private-Deklarationen }
public
{ Public-Deklarationen }
end;
var
APA_Application: TAPA_Application;
first:boolean=true;
APAFilename:string ='C:\APA\SAVE\Default.apa';
mustsave:boolean =false;
var Fcounter:file of Countertype;
vcounter:Countertype;
FCountermerk:file of Countertype;
vcountermerk:Countertype;
FCubes:file of Cubestype;
vcubes:Cubestype;
FKosten:file of Kostentype;
vkosten:Kostentype;
FMatCubes:file of ReqCubestype;
vMatcubes:reqcubestype;
FReqCubes:file of ReqCubestype;
vreqcubes:ReqCubestype;
FMerkkosten:file of Merkkostentype;
vmerkkosten:Merkkostentype;
implementation
uses APA_Parameterunit, APA_Selectionunit, APA_Gridunit,
APA_Optionsunit, APA_Analyseunit, APA_Input_Screenunit,
APA_Show_costsunit, APA_Processunit, APA_Dialogunit, APA_Helpunit;
{$R *.dfm}
procedure TAPA_Application.Kostensortieren();
var pos:longint;
var k1,k2:Kostentype;
var max:longint;
begin
max:=filesize(fKosten)-1;
pos:=max;
- 263 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
repeat;
if (pos>=1) then begin
seek(fKosten,pos);
read(fKosten,k1);
seek(fKosten,pos-1);
read(fKosten,k2);
if
((k1.VonSpalte=k2.vonspalte)and(k1.VonZeile=k2.vonzeile)and(k1.ZuSpalte<k2.zuspalt
e)and(k1.ZuZeile=k2.zuzeile))
then pos:=pos-1
else begin
if (k1.VonSpalte<k2.vonspalte)
or((k1.VonSpalte=k2.vonspalte)and(k1.VonZeile<k2.vonzeile))
or((k1.VonSpalte=k2.vonspalte)and(k1.VonZeile=k2.vonzeile)and(k1.ZuSpalte<k2.zuspa
lte))
or((k1.VonSpalte=k2.vonspalte)and(k1.VonZeile=k2.vonzeile)and(k1.ZuSpalte=k2.zuspa
lte)and(k1.ZuZeile<k2.zuzeile))
then begin
//Grösser
//Austauschen
seek(fKosten,pos);
write(fKosten,k2);
seek(fKosten,pos-1);
write(fKosten,k1);
pos:=pos+2;
if pos>max then pos:=max;
end else begin
//Kleiner =OK
pos:=pos-1;
end;
end; //von<>
end;
until (Pos<=1);
{Ausgabe der Cubes}
{pos:=0;
repeat;
if pos<=max-1 then begin
seek(fKosten,pos);
read(fKosten,k1);
APA_Show_Process.ausgabe(inttostr(k1.VonSpalte)+':'+inttostr(k1.VonZeile)+':'+inttostr(k
1.ZuSpalte)+':'
+inttostr(k1.ZuZeile)+':'+Floattostr(k1.Query)+':'+Floattostr(k1.Build));
end;
pos:=pos+1;
until pos>=max;}
end;
function
TAPA_Application.findkosten(vonspalte,vonzeile,zuspalte,zuzeile:longint):Boolean;
var pos,bereich,max:longint;
var k1:Kostentype;
var gefunden:booleaN;
var abbruch:longint;
begin
{$i-}
abbruch:=0;
max:=filesize(fKosten)-1;
gefunden:=false;
pos:=trunc((filesize(fKosten)+1)/2);
bereich:=pos;
seek(fKosten,pos);
read(fKosten,k1);
repeat;
if
((k1.VonSpalte=vonspalte)and(k1.VonZeile=vonzeile)and(k1.ZuSpalte=zuspalte)and(k1.
ZuZeile=zuzeile))
- 264 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
then begin;bereich:=0;gefunden:=true;end
else begin
if (k1.VonSpalte<vonspalte)
or((k1.VonSpalte=vonspalte)and(k1.VonZeile<vonzeile))
or((k1.VonSpalte=vonspalte)and(k1.VonZeile=vonzeile)and(k1.ZuSpalte<zuspalte))
or((k1.VonSpalte=vonspalte)and(k1.VonZeile=vonzeile)and(k1.ZuSpalte=zuspalte)and(k
1.ZuZeile<zuzeile))
then begin
//Grösser
bereich:=trunc((bereich+1)/2);
pos:=pos+bereich;
if pos>max then pos:=max;
end else begin
//Kleiner
bereich:=trunc((bereich+1)/2);
pos:=pos-bereich;
if pos<0 then pos:=0;
end;
seek(fKosten,pos);
read(fKosten,k1);
end; //von<>
if bereich=1 then abbruch:=abbruch+1;
until (bereich<1)or (abbruch>2);
{$i+}
if ioresult<>0 then gefunden:=false;
if gefunden=true then begin
vKosten:=k1;
Result:=true;
end else begin;
Result:=false;
end;
end;
procedure TAPA_Application.Parameter1Click(Sender: TObject);
begin
APA_Parameter.showmodal;
end;
procedure TAPA_Application.Lade(Filename:string);
var APA_File:TextFile;
st,st2,st3:string;
var first2,fehler:boolean;
var counter:longint;
var fStreamladen,fStreamspeichern:TFileStream;
begin
fehler:=false;
try
APA_Grid.Removedeterministicsolution1Click(self);
APA_Grid.Removepossiblecubes1Click(self);
APA_Show_Process.ButtonPause.Visible:=false;
APA_Show_Process.show;
APA_Show_Process.APA_Protocoll.Clear;
APA_Show_Process.ausgabe('Loading File: '+Filename);
APA_Show_Process.ausgabe('Loading APA Data ...');
APA_Application.Enabled:=false;
try
assignfile(APA_File,Filename);
{$i-}
reset(APA_File);
{$i+}
if ioresult<>0 then begin;
- 265 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Filename:='C:\APADIR\SAVE\Default.apa';
assignfile(APA_File,'C:\APADIR\SAVE\Default.apa');
reset(APA_File);
end;
first2:=true;
APA_Input_Screen.Eingabe.Items.Clear;
st:='';
while (not eof(APA_File))and(st<>'Ende Req') do begin
readln(APA_File,st);
if (st<>'Ende Input')and(st<>'Ende Req')and(st<>'Ende Keybox') then begin
st2:=copy(st,1,5);
st3:=copy(st,6,5);
st:=copy(st,11,500);
if APA_Input_Screen.Eingabe.Selected<>Nil then begin
while (APA_Input_Screen.Eingabe.Selected.GetNext<>nil) do
APA_Input_Screen.Eingabe.Selected:=APA_Input_Screen.Eingabe.Selected.GetNext;
end;
if (strtoint(st3)=1) then begin
if first2=true then begin
APA_Input_Screen.Eingabe.Selected:=APA_Input_Screen.Eingabe.Items.Add(nil,st);
APA_Input_Screen.Eingabe.Selected.ImageIndex:=strtoint(st3);
APA_Input_Screen.Eingabe.Selected.SelectedIndex:=strtoint(st3);
end
else
APA_Input_Screen.Eingabe.Selected:=APA_Input_Screen.Eingabe.Items.Add(APA_Input_Sc
reen.Eingabe.Selected,
st);
APA_Input_Screen.Eingabe.Selected.ImageIndex:=strtoint(st3);
APA_Input_Screen.Eingabe.Selected.SelectedIndex:=strtoint(st3);
end else begin
if APA_Input_Screen.Eingabe.Selected.Level=0 then
APA_Input_Screen.Eingabe.Selected:=APA_Input_Screen.Eingabe.Items.AddChild(APA_Inp
ut_Screen.Eingabe.Selected,
st)
else
APA_Input_Screen.Eingabe.Selected:=APA_Input_Screen.Eingabe.Items.Add(APA_Input_Sc
reen.Eingabe.Selected,
st);
APA_Input_Screen.Eingabe.Selected.ImageIndex:=strtoint(st3);
APA_Input_Screen.Eingabe.Selected.SelectedIndex:=strtoint(st3);
end;
end;
end;//Ende von while1
APA_Selection_Screen.Req.items.clear;
while (not eof(APA_File))and(st<>'Ende Input') do begin
readln(APA_File,st);
if (st<>'Ende Input')and(st<>'Ende Req')and(st<>'Ende Selection')and(st<>'Ende
Keybox') then begin
st2:=copy(st,1,5);
st3:=copy(st,6,5);
st:=copy(st,11,500);
if APA_Input_Screen.Eingabe.Selected<>Nil then begin
while (APA_Input_Screen.Eingabe.Selected.GetNext<>nil) do
APA_Input_Screen.Eingabe.Selected:=APA_Input_Screen.Eingabe.Selected.GetNext;
end;
if (strtoint(st2)=0) then begin
if first2=true then begin
APA_Selection_Screen.Req.Selected:=APA_Selection_Screen.Req.Items.Add(nil,st);
APA_Selection_Screen.Req.Selected.ImageIndex:=strtoint(st3);
APA_Selection_Screen.Req.Selected.SelectedIndex:=strtoint(st3);
end
else
- 266 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
APA_Selection_Screen.Req.Selected:=APA_Selection_Screen.Req.Items.Add(APA_Selectio
n_Screen.Req.Selected,
st);
APA_Selection_Screen.Req.Selected.ImageIndex:=strtoint(st3);
APA_Selection_Screen.Req.Selected.SelectedIndex:=strtoint(st3);
end else begin
if APA_Selection_Screen.Req.Selected.Level=0 then
APA_Selection_Screen.Req.Selected:=APA_Selection_Screen.Req.Items.AddChild(APA_Sel
ection_Screen.Req.Selected,
st)
else
APA_Selection_Screen.Req.Selected:=APA_Selection_Screen.REq.Items.Add(APA_Selectio
n_Screen.Req.Selected,
st);
APA_Selection_Screen.Req.Selected.ImageIndex:=strtoint(st3);
APA_Selection_Screen.Req.Selected.SelectedIndex:=strtoint(st3);
end;
end;
end;//Ende von while2
APA_Selection_Screen.Listeint.Items.Clear;
while ((not eof(APA_File))and(st<>'Ende Selection')) do begin
readln(APA_File,st);
if (st<>'Ende Input')and(st<>'Ende Req')and(st<>'Ende Selection')and(st<>'Ende
Keybox') then begin
APA_Selection_Screen.Listeint.Items.Add(st);
end;
end;//Ende von While3
APA_Grid_button.Enabled:=true;
Button_Apa_Selection.Enabled:=true;
APA_Grid.bezeichnungenholen();
generiereapaneu:=true;
APA_Grid.FormShow(self);
//Begin while 4
Matcount:=0;
while (not eof(APA_File)and(st<>'Ende Cubes')) do begin
readln(APA_File,st);
if (st<>'Ende Input')and(st<>'Ende Req')and(st<>'Ende Selection')and(st<>'Ende
Keybox')and(st<>'Ende Cubes') then begin
if copy(st,1,1)='R' then begin
APA[strtoint(copy(st,2,30)),strtoint(copy(st,32,30))].interessant:=true;
APA[strtoint(copy(st,2,30)),strtoint(copy(st,32,30))].gewicht:=strtofloat(copy(st,
62,30));
APA[strtoint(copy(st,2,30)),strtoint(copy(st,32,30))].gewichtlevel:=strtoint(copy(
st,92,30));
end;
if copy(st,1,1)='M' then begin
APA[strtoint(copy(st,2,30)),strtoint(copy(st,32,30))].materalisieren:=true;
APA[strtoint(copy(st,2,30)),strtoint(copy(st,32,30))].matcount:=strtoint(copy(st,6
2,30));
Matcount:=Matcount+1;
end;
end;
end;//Ende von While4
APA_Input_Screen.Keybox.Clear;
while ((not eof(APA_File))and(st<>'Ende Keybox')) do begin
- 267 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
readln(APA_File,st);
if (st<>'Ende Input')and(st<>'Ende Req')and(st<>'Ende Selection')and(st<>'Ende
Keybox')and(st<>'Ende Cubes') then begin
APA_Input_Screen.Keybox.Items.Add(st);
end;
end;//Ende von While5
if (not eof(APA_File)) then begin
readln(APA_File,st);
APA_Parameter.APA_Thomas_timestore.text:=st;
readln(APA_File,st);
APA_Parameter.APA_Thomas_timeio.text:=st;
readln(APA_File,st);
APA_Parameter.APA_Thomas_avsizeoftupel.text:=st;
readln(APA_File,st);
APA_Parameter.APA_Thomas_timemax.text:=st;
readln(APA_File,st);
APA_Parameter.APA_Thomas_spacemax.text:=st;
readln(APA_File,st);
APA_Parameter.APA_Thomas_Importance.Position:=strtoint(st);
readln(APA_File,st);
APA_Parameter.APA_Thomas_Query_Importance.Position:=strtoint(st);
readln(APA_File,st);
if st<>'Ende Parameter' then begin
APA_Parameter.APA_Thomas_newsetsoneachiteration.text:=st;
readln(APA_File,st);
APA_Parameter.APA_Thomas_countofsets.text:=st;
readln(APA_File,st);
end;
if st<>'Ende Parameter' then begin
APA_Parameter.APA_Thomas_timecpu.text:=st;
readln(APA_File,st);
end;
if st<>'Ende Parameter' then begin
if st='True' then
Permutation:=true else Permutation:=false;
readln(APA_File,st);
end;
if st<>'Ende Parameter' then begin
APA_Parameter.APA_Thomas_querytimemax.text:=st;
readln(APA_File,st);
if st='True' then
APA_Grid.Userandomcosts1.Checked:=true else APA_Grid.Userandomcosts1.Checked:=false;
readln(APA_File,st);
end;
if (not(Eof(APA_File))) then begin
st:='';APA_Parameter.APA_Degrees.clear;
while(not(Eof(APA_File)))and(st<>'Ende Degrees') do begin
readln(APA_File,st);
if st<>'Ende Degrees' then APA_Parameter.APA_Degrees.Items.Add(st);
end;
st:='';APA_Parameter.APA_Degreecounts.Clear;
while(not(Eof(APA_File)))and(st<>'Ende Degreescount') do begin
readln(APA_File,st);
if st<>'Ende Degreescount' then APA_Parameter.APA_Degreecounts.items.Add(st);
end;
for counter:=0 to 14 do begin
readln(APA_File,st);
DegreeColors[counter]:=strtoint(st);
end;
readln(APA_File,st);
for counter:=0 to 14 do begin
readln(APA_File,st);
Othercolors[counter]:=strtoint(st);
end;
readln(APA_File,st);
- 268 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end;//Ende von Eof2 dient der Rückwärtskompartibilität
end;//Ende von not EOF
APA_Grid.materialzeichnen;
finally
CloseFile(APA_File);
if uppercase(APAFilename)<>uppercase('C:\APADIR\SAVE\Default.apa')
then
APA_Application.Caption:='APA Application - '+APAFilename
else
APA_Application.Caption:='APA Application ';
end;
try
APA_Show_Process.ausgabe('Loading costs');
//Lade auch die Kosten
//Lade aus Spezialdatei
if fileexists(ExtractFilePath(filename)+
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))-3)+'ape')
then begin
try
fStreamLaden:=TFileStream.Create(ExtractFilePath(filename)+
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))3)+'ape',fmOpenRead);
try
fStreamSpeichern:=TFileStream.Create('C:\APADIR\DATA\Kosten.dat',fmCreate);
fStreamSpeichern.CopyFrom(fStreamLaden, fStreamLaden.Size);
finally
freeandnil(fStreamSpeichern);
end;
finally
freeandnil(fStreamLaden);
end;
end;
APA_Show_Process.ausgabe('Loading solution costs');
//Lade aus Spezialdatei
if fileexists(ExtractFilePath(filename)+
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))-3)+'apf')
then begin
try
fStreamLaden:=TFileStream.Create(ExtractFilePath(filename)+
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))3)+'apf',fmOpenRead);
try
fStreamSpeichern:=TFileStream.Create('C:\APADIR\DATA\Merkkosten.dat',fmCreate);
fStreamSpeichern.CopyFrom(fStreamLaden, fStreamLaden.Size);
finally
freeandnil(fStreamSpeichern);
end;
finally
freeandnil(fStreamLaden);
end;
end;
APA_Show_Process.ausgabe('Loading cubes');
//Lade aus Spezialdatei
if fileexists(ExtractFilePath(filename)+
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))-3)+'apd')
then begin
try
fStreamLaden:=TFileStream.Create(ExtractFilePath(filename)+
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))3)+'apd',fmOpenRead);
- 269 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
try
fStreamSpeichern:=TFileStream.Create('C:\APADIR\DATA\Cubes.dat',fmCreate);
fStreamSpeichern.CopyFrom(fStreamLaden, fStreamLaden.Size);
finally
freeandnil(fStreamSpeichern);
end;
finally
freeandnil(fStreamLaden);
end;
end;
APA_Show_Process.ausgabe('Loading counter');
//Lade aus Spezialdatei
if fileexists(ExtractFilePath(filename)+
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))-3)+'apb')
then begin
try
fStreamLaden:=TFileStream.Create(ExtractFilePath(filename)+
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))3)+'apb',fmOpenRead);
try
fStreamSpeichern:=TFileStream.Create('C:\APADIR\DATA\Counter.dat',fmCreate);
fStreamSpeichern.CopyFrom(fStreamLaden, fStreamLaden.Size);
finally
freeandnil(fStreamSpeichern);
end;
finally
freeandnil(fStreamLaden);
end;
end;
APA_Show_Process.ausgabe('Loading solution');
//Lade aus Spezialdatei
if fileexists(ExtractFilePath(filename)+
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))-3)+'apc')
then begin
try
fStreamLaden:=TFileStream.Create(ExtractFilePath(filename)+
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))3)+'apc',fmOpenRead);
try
fStreamSpeichern:=TFileStream.Create('C:\APADIR\DATA\Countermerk.dat',fmCreate);
fStreamSpeichern.CopyFrom(fStreamLaden, fStreamLaden.Size);
finally
freeandnil(fStreamSpeichern);
end;
finally
freeandnil(fStreamLaden);
end;
end;
except
showmessage('Could not load costs');
fehler:=true;
end;
finally
APA_Application.Enabled:=true;
APA_Show_Process.ButtonCancel.Caption:='Close';
if fehler=false then
APA_Show_Process.Ausschalten.Enabled:=true
else
APA_Show_Process.ButtonCancel.Caption:='Close';
mustsave:=false;
end;
end;
procedure TAPA_Application.Open1Click(Sender: TObject);
- 270 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
begin
APAOpendialog.InitialDir:=
APA_Options.APA_Save_Path.Directory;
If APAOpendialog.Execute then begin
if mustsave=true then begin
APA_Dialog.APA_Text.Caption:='You did not save your APA. Do you want to save?';
if APA_Dialog.showmodal=mryes then begin;
if APAFilename='C:\APADIR\SAVE\Default.apa' then
Saveas1Click(self) else
Speichern(APAFilename);
end;
end;
APAFilename:=APAOpendialog.FileName;
Lade(APAFileName);
end;
end;
procedure TAPA_Application.Speichern(Filename:string);
var APA_File: TextFile;
counter,counter2:longint;
st:string;
fStreamladen,fStreamspeichern:TFileStream;
begin
try
APA_Show_Process.ButtonPause.Visible:=false;
APA_Show_Process.show;
APA_Show_Process.APA_Protocoll.Clear;
APA_Show_Process.ausgabe('Saving File: '+Filename);
APA_Show_Process.ausgabe('Save APA Data ...');
APA_Application.Enabled:=false;
assignfile(APA_File,APAFilename);
try
rewrite(APA_File);
APA_Show_Process.ausgabe('Save APA Input Screen');
for counter:=0 to APA_Input_Screen.Eingabe.Items.Count-1 do begin
st:=APA_Grid.auffuellen(inttostr(APA_Input_Screen.Eingabe.Items[counter].Level),5)+
APA_Grid.auffuellen(inttostr(APA_Input_Screen.Eingabe.Items[counter].Imageindex),5
)+
APA_Input_Screen.Eingabe.Items[counter].Text;
writeln(APA_File,st);
end;
writeln(APA_File,'Ende Req');
APA_Show_Process.ausgabe('Save APA Selection Screen');
for counter:=0 to APA_Selection_Screen.Req.Items.Count-1 do begin
st:=APA_Grid.auffuellen(inttostr(APA_Selection_Screen.Req.Items[counter].Level),5)+
APA_Grid.auffuellen(inttostr(APA_Selection_Screen.Req.Items[counter].ImageIndex),5
)+
APA_Selection_Screen.Req.Items[counter].Text;
writeln(APA_File,st);
end;
writeln(APA_File,'Ende Input');
for counter:=0 to APA_Selection_Screen.Listeint.Items.Count-1 do begin
st:=APA_Selection_Screen.Listeint.Items[counter];
writeln(APA_File,st);
end;
writeln(APA_File,'Ende Selection');
APA_Show_Process.ausgabe('Save required and materialized cubes');
for counter:=0 to anzzeilen-1 do begin
for counter2:=0 to anzspalten-1 do begin
- 271 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if (APA[counter2,counter].interessant=true) then begin
st:='R'+APA_Grid.auffuellen(inttostr(counter2),30)+APA_Grid.auffuellen(inttostr(co
unter),30)+
APA_Grid.auffuellen(floattostr(APA[counter2,counter].gewicht),30)+APA_Grid.auffuel
len(inttostr(APA[counter2,counter].gewichtlevel),30);
writeln(APA_File,st);
end;
if (APA[counter2,counter].materalisieren=true) then begin
st:='M'+APA_Grid.auffuellen(inttostr(counter2),30)+APA_Grid.auffuellen(inttostr(co
unter),30)+
APA_Grid.auffuellen(inttostr(APA[counter2,counter].matcount),30);
writeln(APA_File,st);
end;
end;
end;
writeln(APA_File,'Ende Cubes');
APA_Show_Process.ausgabe('Save APA Input Screen Keybox');
for counter:=0 to APA_Input_Screen.keybox.Items.Count-1 do begin
writeln(APA_File,APA_Input_Screen.keybox.Items[counter]);
end;
writeln(APA_File,'Ende Keybox');
APA_Show_Process.ausgabe('Save APA Parameter');
writeln(APA_File,APA_Parameter.APA_Thomas_timestore.text);
writeln(APA_File,APA_Parameter.APA_Thomas_timeio.text);
writeln(APA_File,APA_Parameter.APA_Thomas_avsizeoftupel.text);
writeln(APA_File,APA_Parameter.APA_Thomas_timemax.text);
writeln(APA_File,APA_Parameter.APA_Thomas_spacemax.text);
writeln(APA_File,inttostr(APA_Parameter.APA_Thomas_Importance.Position));
writeln(APA_File,inttostr(APA_Parameter.APA_Thomas_Query_Importance.Position));
writeln(APA_File,APA_Parameter.APA_Thomas_newsetsoneachiteration.text);
writeln(APA_File,APA_Parameter.APA_Thomas_countofsets.text);
writeln(APA_File,APA_Parameter.APA_Thomas_timecpu.text);
if Permutation=true then
writeln(APA_File,'True')else writeln(APA_File,'False');
writeln(APA_File,APA_Parameter.APA_Thomas_querytimemax.text);
if APA_Grid.Userandomcosts1.Checked=true then
writeln(APA_File,'True')else writeln(APA_File,'False');
writeln(APA_File,'Ende Parameter');
for counter:=0 to APA_Parameter.APA_Degrees.Items.Count-1 do begin
writeln(APA_File,APA_Parameter.APA_Degrees.Items[counter]);
end;
writeln(APA_File,'Ende Degrees');
for counter:=0 to APA_Parameter.APA_Degreecounts.Items.Count-1 do begin
writeln(APA_File,APA_Parameter.APA_Degreecounts.Items[counter]);
end;
writeln(APA_File,'Ende Degreescount');
for counter:=0 to 14 do begin
writeln(APA_File,inttostr(DegreeColors[counter]));
end;
writeln(APA_File,'Ende Farben');
for counter:=0 to 14 do begin
writeln(APA_File,inttostr(Othercolors[counter]));
end;
writeln(APA_File,'Ende Andere Farben');
finally
Closefile(APA_File);
APA_Application.Caption:='APA Application - '+APAFilename;
- 272 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end;
try
APA_Show_Process.ausgabe('Save costs');
//Speichere auch die Kosten
//Speichere in Spezialdatei
{$i-}
CloseFile(fKosten);
{$i+}
if ioresult<>0 then APA_Show_Process.ausgabe('Close cost database');
try
fStreamLaden:=TFileStream.Create('C:\APADIR\DATA\Kosten.dat',fmOpenRead);
try
fStreamSpeichern:=TFileStream.Create(ExtractFilePath(filename)+
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))3)+'ape',fmCreate);
fStreamSpeichern.CopyFrom(fStreamLaden, fStreamLaden.Size);
finally
freeandnil(fStreamSpeichern);
end;
finally
freeandnil(fStreamLaden);
end;
APA_Show_Process.ausgabe('Save solution');
//Speichere in Spezialdatei
try
fStreamLaden:=TFileStream.Create('C:\APADIR\DATA\Countermerk.dat',fmOpenRead);
try
fStreamSpeichern:=TFileStream.Create(ExtractFilePath(filename)+
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))3)+'apc',fmCreate);
fStreamSpeichern.CopyFrom(fStreamLaden, fStreamLaden.Size);
finally
freeandnil(fStreamSpeichern);
end;
finally
freeandnil(fStreamLaden);
end;
APA_Show_Process.ausgabe('Save cubes');
//Speichere in Spezialdatei
try
fStreamLaden:=TFileStream.Create('C:\APADIR\DATA\Cubes.dat',fmOpenRead);
try
fStreamSpeichern:=TFileStream.Create(ExtractFilePath(filename)+
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))3)+'apd',fmCreate);
fStreamSpeichern.CopyFrom(fStreamLaden, fStreamLaden.Size);
finally
freeandnil(fStreamSpeichern);
end;
finally
freeandnil(fStreamLaden);
end;
APA_Show_Process.ausgabe('Save counter');
//Speichere in Spezialdatei
try
fStreamLaden:=TFileStream.Create('C:\APADIR\DATA\Counter.dat',fmOpenRead);
try
fStreamSpeichern:=TFileStream.Create(ExtractFilePath(filename)+
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))3)+'apb',fmCreate);
fStreamSpeichern.CopyFrom(fStreamLaden, fStreamLaden.Size);
finally
freeandnil(fStreamSpeichern);
end;
finally
freeandnil(fStreamLaden);
end;
- 273 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
APA_Show_Process.ausgabe('Save solution costs');
//Speichere in Spezialdatei
try
fStreamLaden:=TFileStream.Create('C:\APADIR\DATA\Merkkosten.dat',fmOpenRead);
try
fStreamSpeichern:=TFileStream.Create(ExtractFilePath(filename)+
copy(ExtractFilename(filename),1,length(ExtractFilename(filename))3)+'apf',fmCreate);
fStreamSpeichern.CopyFrom(fStreamLaden, fStreamLaden.Size);
finally
freeandnil(fStreamSpeichern);
end;
finally
freeandnil(fStreamLaden);
end;
except
showmessage('Could not save costs');
end;
finally
APA_Show_Process.ButtonCancel.Caption:='Close';
APA_Show_Process.Ausschalten.Enabled:=true;
APA_Application.Enabled:=true;
mustsave:=false;
end;
end;
procedure TAPA_Application.Saveas1Click(Sender: TObject);
begin
APASavedialog.InitialDir:=
APA_Options.APA_Save_Path.Directory;
if APASavedialog.Execute then begin
APAFilename:= APASavedialog.FileName;
Speichern(APAFilename);
end;
end;
procedure TAPA_Application.Exit1Click(Sender: TObject);
begin
Close;
end;
procedure TAPA_Application.InputScreen1Click(Sender: TObject);
begin
APA_Input_Screen_buttonClick(self);
end;
procedure TAPA_Application.APAGridScreen1Click(Sender: TObject);
begin
APA_Grid_buttonClick(self);
end;
procedure TAPA_Application.APASelectionScreen1Click(Sender: TObject);
begin
Button_Apa_SelectionClick(self);
end;
procedure TAPA_Application.Options1Click(Sender: TObject);
begin
APA_Options.showmodal;
end;
procedure TAPA_Application.APA_Input_Screen_buttonClick(Sender: TObject);
begin
APA_Application.Hide;
try
APA_Input_Screen.ShowModal
finally
- 274 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
APA_Application.Show;
end;
end;
procedure TAPA_Application.APA_Grid_buttonClick(Sender: TObject);
begin
APA_Application.Hide;
{Generieren des APA }
try
gotoInput:=false;
gotoSelection:=false;
bezeichnungenkontrolliert:=false;
APA_Grid.bezeichnungenholen();
if bezeichnungenkontrolliert=true then begin;
APA_Grid.WindowState:=wsMaximized;
APA_Grid.showmodal;
Button_APA_Selection.Enabled:=true;
end else
begin;
gotoInput:=true;
end;
if gotoInput=true then begin;gotoInput:=false;APA_Input_Screen_button.Click;end;
if gotoSelection=true then begin;gotoSelection:=false;Button_Apa_Selection.Click;end;
finally
APA_Application.Show;
end;
end;
procedure TAPA_Application.Button_Apa_SelectionClick(Sender: TObject);
var zahler:longint;
begin
APA_Application.Hide;
try
{Laden der möglichen Dimensionen und Hierarchiestufen}
{1. Dimensionen laden}
with APA_Selection_Screen do begin
Dimensionbox.Items.Clear;
Hierarchybox.Items.Clear;
for zahler:= 0 to anzd-1 do begin
Dimensionbox.Items.Add(dimbez[zahler]);
end;
Dimensionbox.itemindex:=0;
{Füllen der Hierarchien}
hierarchybox.Items.Clear;
{Hole die Hierarchiestufen}
for zahler:=0 to anzh[Dimensionbox.itemindex]-1 do begin
Hierarchybox.Items.Add(dl[Dimensionbox.itemindex][zahler])
end;
Hierarchybox.ItemIndex:=0;
Methodbox.ItemIndex:=0;
End_of_methodbox.Enabled:=false;
end;{Ende von APA_Selection_Screen}
APA_Selection_Screen.WindowState:=wsMaximized;
APA_Selection_Screen.showmodal;
if gotoAPA=true then begin;gotoAPA:=false;APA_Grid_Button.Click;end;
finally
- 275 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
APA_Application.Show;
end;
end;
procedure TAPA_Application.FormActivate(Sender: TObject);
var merkfile:TextFile;
st:string;
var fStreamladen,fStreamspeichern:TFileStream;
begin
if first=true then begin;
{showmessage('Dies ist eine Betaversion. Für Fehler oder unrichtige Ergebnisse wird
keine Garantie übernommen. c)Thomas ACHS');}
first:=false;
assignfile(merkfile,'C:\APADIR\PROGRAM\Settings.tom');
try
reset(merkfile);
readln(merkfile,APAFilename);
readln(merkfile,st);
if st='True' then
APA_Options.APA_Load_Last_APA.Checked:=true else
APA_Options.APA_Load_Last_APA.Checked:=false;
readln(merkfile,st);
if st='True' then
APA_Options.APA_Save_on_termination.Checked:=true else
APA_Options.APA_Save_on_termination.Checked:=false;
readln(merkfile,st);
if st='True' then
APA_Options.APA_Remove_redundancy.Checked:=true else
APA_Options.APA_Remove_redundancy.Checked:=false;
APA_Grid.Remove_Redundancy.Checked:=APA_Options.APA_Remove_redundancy.Checked;
readln(merkfile,st);
if st='True' then
APA_Options.APA_Add_max_hier.Checked:=true else
APA_Options.APA_Add_max_hier.Checked:=false;
readln(merkfile,st); //Früher Saverandomcosts
if st='True' then
APA_Options.APA_Show_Link_on_Desktop.Checked:=true else
APA_Options.APA_Show_Link_on_Desktop.Checked:=false;
readln(merkfile,st);
APA_Options.APA_Save_Path.Directory:=st;
if not(eof(merkfile)) then begin
readln(merkfile,st);
if st='True' then
APA_Options.APA_ShowScreenheuristic.Checked:=true else
APA_Options.APA_ShowScreenheuristic.Checked:=false;
end;
finally
Closefile(merkfile);
end;
if APA_Options.APA_Load_Last_APA.Checked=true then begin
//Lade
Lade(APAFilename);
end else begin;
Lade('c:\APADIR\Save\Default.APA');
end;
if APA_Options.APA_Show_Link_on_Desktop.Checked=true then begin
if fileexists(shelldir.Path+'\APAWin.lnk')=false then begin
try
- 276 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
fStreamLaden:=TFileStream.Create('c:\APADIR\PROGRAM\APAWin.lnk',fmOpenRead);
try
fStreamSpeichern:=TFileStream.Create(shelldir.Path+'\APAWin.lnk',fmCreate);
fStreamSpeichern.CopyFrom(fStreamLaden, fStreamLaden.Size);
finally
freeandnil(fStreamSpeichern);
end;
finally
freeandnil(fStreamLaden);
end;
end else begin
//Löschen
if fileexists(shelldir.Path+'\APAWin.lnk')=true then begin
try
deletefile(shelldir.Path+'\APAWin.lnk');
except
showmessage('Can not remove link from Desktop');
end;
end;
end;
end;
end;
end;
procedure TAPA_Application.GeneriereZufallskosten1Click(Sender: TObject);
var hauptspalte,hauptzeile,aktspalte,aktzeile:longint;
Maxkosten, maxkosten2,KostenvomBFT,
KostenvomBFT2, KostenParent,KostenParent2:longint;
costmerk:longint;
parentspalte,parentzeile:longint;
bandbreite:longint;
begin
if generiereapaneu=true then begin
APA_Grid.FormShow(self);
end;
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');
{$i-}
rewrite(fKosten);
{$i+}
if ioresult<>0 then begin; showmessage('cost database error ');exit;end;
try
APA_Show_Process.ButtonPause.Visible:=false;
APA_Show_Process.show;
APA_Application.Enabled:=false;
bandbreite:=100000;
stop:=false;
APA_Show_Process.APA_Protocoll.Clear;
APA_Show_Process.ausgabe('Build Costs ...');
Randomize;
//Zuerst lösche alle alten Kosten aus der Tabelle
APA_Show_Process.ausgabe('Clear costs...');
//Generiere alle Kanten indem von jedem Würfel die Kanten zu allen seinen Derivaten
bewertet werden
//und die Kosten vom BFT zu dem Würfel die max Kosten sind 10000
if APA_Application.Restrictedcosts1.Checked=true then begin
//**************************************
// Erster Lauf
//**************************************
//Bewerte alle Kosten aus dem BFT
- 277 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
for hauptspalte:=0 to anzspalten-1 do begin
for hauptzeile:=0 to anzzeilen-1 do begin
if APA[hauptspalte,hauptzeile].farbe=clYellow then begin
//Suche alle Parents und merke die die geringsten Kosten des Parents
maxkosten2:=bandbreite;
maxkosten:=bandbreite;
for aktspalte:=0 to anzspalten-1 do begin
for aktzeile:=0 to anzzeilen-1 do begin
if APA[aktspalte,aktzeile].farbe=clYellow then begin
if
(APA_Grid.isderivat(aktspalte,aktzeile,hauptspalte,hauptzeile)=true)
and (not((hauptspalte=aktspalte)and(hauptzeile=aktzeile))) then
begin
if findkosten(-1,-1,aktspalte,aktzeile)=true then begin
if vkosten.Query<maxkosten2 then
maxkosten2:=round(vkosten.query);
if vkosten.Build<maxkosten then maxkosten:=round(vkosten.build);
end;
end;//isderivat
end;//von farbe Redundant
end;//Ende von aktzeile
end;//Ende von aktspalte
//Zufallskosten vom BFT
KostenvomBFT:=1+random(maxkosten-1);//Materialisierungskosten
KostenvomBFT2:=1+random(min(KostenvomBFT,maxkosten2)-1);//Abfragekosten
APA_Show_Process.ausgabe('Build First BFT('+inttostr(hauptspalte)+
':'+inttostr(hauptzeile)+'):
'+inttostr(KostenvomBFT2)+'/'+inttostr(KostenvomBFT));
//Eintragen der Kosten vom BFT
seek(fKosten,filesize(fKosten));
vkosten.VonSpalte:=-1;
vkosten.VonZeile:=-1;
vkosten.ZuSpalte:=hauptspalte;
vkosten.ZUZeile:=hauptzeile;
vkosten.Query:=KostenvomBFT2;
vkosten.Build:=KostenvomBFT;
write(fKosten,vkosten);Kostensortieren;
end;//Ende von nicht Redundant
end;//Ende Zeile
end;//Ende von Spalte
//**************************************
// Zweiter Lauf - Kosten zwischen den Cubes berechnen
//**************************************
APA_Show_Process.ausgabe('Start second run...');
for hauptspalte:=0 to anzspalten-1 do begin
for hauptzeile:=0 to anzzeilen-1 do begin
if APA[hauptspalte,hauptzeile].farbe=clYellow then begin
APA_Show_Process.ausgabe('Kontrolliere Cube
('+inttostr(hauptspalte)+':'+inttostr(hauptzeile)+')');
//Durchlaufen der Derivate des Würfels
//Die Kosten für die Derivate können nicht größer sein als das Erzeugen aus dem
BFT
//oder die Kosten des Vorgängers von seinem Derivat
for aktspalte:=0 to anzspalten-1 do begin
for aktzeile:=0 to anzzeilen-1 do begin
if APA[aktspalte,aktzeile].farbe=clYellow then begin
- 278 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
If (APA_Grid.isderivat(aktspalte,aktzeile,hauptspalte,hauptzeile)=true)and
(not((hauptspalte=aktspalte)and(hauptzeile=aktzeile)))
//Der Parent aggregiert die gleiche Dimension
then begin
//Suche Maxkosten vom BFT
if (findkosten(-1,-1,hauptspalte,hauptzeile)=true) then begin
maxkosten:=round(vkosten.Build);
maxkosten2:=round(vKosten.Query);
end else begin
maxkosten:=bandbreite;
maxkosten2:=bandbreite;
end;
//Kosten der Materialisierung vom BFT
costmerk:=round(APA_Grid.getbuild(-1,-1,hauptspalte,hauptzeile));
if (costmerk<maxkosten) then maxkosten:=costmerk;
costmerk:=round(APA_Grid.getquery(-1,-1,hauptspalte,hauptzeile));
if (costmerk<maxkosten2) then maxkosten2:=costmerk;
//Kosten einer Parents gleicher Dimension
if
(APA[aktspalte,aktzeile].countdimension=APA[hauptspalte,hauptzeile].countdimension
)
then begin
//Suche den Parent von diesem Cube, welcher die gleich Hierarchie erhöht
for parentspalte:=0 to anzspalten-1 do begin;
for parentzeile:=0 to anzzeilen-1 do begin;
if
APA_Grid.isderivat(parentspalte,parentzeile,aktspalte,aktzeile)and
(parentspalte<>aktspalte)and(parentzeile<>aktzeile) then begin
if
(APA[aktspalte,aktzeile].countdimension=APA[parentspalte,parentzeile].countdimensi
on)
then begin
costmerk:=round(APA_Grid.getbuild(parentspalte,parentzeile,aktspalte,aktzeile));
if (costmerk<maxkosten) then maxkosten:=costmerk;
costmerk:=round(APA_Grid.getquery(parentspalte,parentzeile,aktspalte,aktzeile));
if (costmerk<maxkosten2) then maxkosten2:=costmerk;
end;//gleich dimension
end;//isderivat
end;//parentspalte
end;//parentzeile
end;
KostenParent:=1+random(maxkosten-1);
KostenParent2:=1+random(maxkosten2-1);
APA_Show_Process.ausgabe('Build from ('+inttostr(aktspalte)+':'+
inttostr(aktzeile)+') to ('+inttostr(hauptspalte)+':'+
inttostr(hauptzeile)+'):
'+inttostr(Kostenparent2)+'/'+inttostr(Kostenparent));
Seek(fKosten,filesize(fKosten));
vKosten.VonSpalte:=aktspalte;
vKosten.VonZeile:=aktzeile;
vKosten.ZuSpalte:=hauptspalte;
vKosten.ZUZeile:=hauptzeile;
vKosten.Query:=KostenParent2;
vKosten.Build:=KostenParent;
write(fKosten,vkosten);Kostensortieren;
end;// is Parent
end;///is yellow
- 279 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end;//aktzeile
end;//aktspalte
end;//Ende von nicht Redundant
end;//Ende Zeile
end;//Ende Spalte
end // von total Random costs
else begin
for hauptzeile:=0 to anzzeilen-1 do begin
for hauptspalte:=0 to anzspalten-1 do begin
if APA[hauptspalte,hauptzeile].farbe=clYellow then begin
{1.Generiere Kosten von BFT}
KostenvomBFT:=1+random(bandbreite-1);//Materialisierungskosten
KostenvomBFT2:=1+random(KostenvomBFT-1);//Abfragekosten
APA_Show_Process.ausgabe('Build BFT('+inttostr(hauptspalte)+
':'+inttostr(hauptzeile)+'):
'+inttostr(KostenvomBFT2)+'/'+inttostr(KostenvomBFT));
//Eintragen der Kosten vom BFT
seek(fKosten,filesize(fKosten));
vKosten.VonSpalte:=-1;
vKosten.VonZeile:=-1;
vKosten.ZuSpalte:=hauptspalte;
vKosten.ZUZeile:=hauptzeile;
vKosten.Query:=KostenvomBFT2;
vKosten.Build:=KostenvomBFT;
write(fKosten,vKosten);Kostensortieren;
{2.Generiere Kosten aller Derivate}
for aktspalte:=0 to anzspalten-1 do begin
for aktzeile:=0 to anzzeilen-1 do begin
if (APA[aktspalte,aktzeile].farbe=clYellow) then begin
if (APA_Grid.isderivat(hauptspalte,hauptzeile,aktspalte,aktzeile)) then begin
//Eintragen der Kosten
KostenvomBFT:=1+random(bandbreite-1);//Materialisierungskosten
KostenvomBFT2:=1+random(KostenvomBFT-1);//Abfragekosten
APA_Show_Process.ausgabe('Build from ('+inttostr(hauptspalte)+':'+
inttostr(hauptzeile)+') to ('+inttostr(aktspalte)+':'+
inttostr(aktzeile)+'):
'+inttostr(KostenvomBFT2)+'/'+inttostr(KostenvomBFT));
//Eintragen der Kosten vom BFT
seek(fKosten,filesize(fKosten));
vKosten.VonSpalte:=hauptspalte;
vKosten.VonZeile:=hauptzeile;
vKosten.ZuSpalte:=aktspalte;
vKosten.ZUZeile:=aktzeile;
vKosten.Query:=KostenvomBFT2;
vKosten.Build:=KostenvomBFT;
write(fKosten,vKosten); Kostensortieren;
end;//isderivat
end;//not redundant
end;//aktzeile
end;//aktspalte
end;//not redundant
end;//hauptspalte
end;//hauptzeile
end;
finally
CloseFile(fKosten);
APA_Application.Enabled:=true;
end;
APA_Show_Process.ButtonCancel.Caption:='Close';
APA_Showcosts.showmodal;
mustsave:=true;
- 280 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
APA_Show_Process.ausgabe('');
APA_Show_Process.ausgabe('READY');
APA_Show_Process.ausgabe('');
end;
procedure TAPA_Application.ShowRandomCosts1Click(Sender: TObject);
begin
APA_Showcosts.showmodal;
end;
procedure TAPA_Application.Save1Click(Sender: TObject);
begin
if uppercase(APAFilename)=uppercase('C:\APADIR\SAVE\Default.apa') then
Saveas1Click(self) else
Speichern(APAFilename);
end;
procedure TAPA_Application.FormCloseQuery(Sender: TObject;
var CanClose: Boolean);
var merkfile:TextFile;
begin
if APA_Options.APA_Save_on_termination.Checked=true then begin
if mustsave=true then Speichern(Apafilename);
end;
if mustsave=true then begin
APA_Dialog.APA_Text.Caption:='You did not save your APA. Do you want to save?';
if APA_Dialog.showmodal=mryes then begin;
Save1Click(self);
end;
end;
assignfile(merkfile,'C:\APADIR\PROGRAM\Settings.tom');
try
rewrite(merkfile);
writeln(merkfile,APAFilename);
if APA_Options.APA_Load_Last_APA.Checked=true then
writeln(merkfile,'True') else
writeln(merkfile,'False');
if APA_Options.APA_Save_on_termination.Checked=true then
writeln(merkfile,'True') else
writeln(merkfile,'False');
if APA_Options.APA_Remove_redundancy.Checked=true then
writeln(merkfile,'True') else
writeln(merkfile,'False');
if APA_Options.APA_Add_max_hier.Checked=true then
writeln(merkfile,'True') else
writeln(merkfile,'False');
if APA_Options.APA_Show_Link_on_Desktop.Checked=true then
writeln(merkfile,'True')
else
writeln(merkfile,'False');
writeln(merkfile,APA_Options.APA_Save_Path.Directory);
if APA_Options.APA_ShowScreenheuristic.Checked=true then
writeln(merkfile,'True') else
writeln(merkfile,'False');
finally
Closefile(merkfile);
end;
end;
- 281 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
procedure TAPA_Application.Restrictedcosts1Click(Sender: TObject);
begin
APA_Grid.Restrictedcosts1.Checked:=APA_Application.Restrictedcosts1.Checked;
end;
procedure TAPA_Application.AnalyseAPA1Click(Sender: TObject);
begin
if generiereapaneu=true then begin
APA_Grid.FormShow(self);
end;
APA_Analyse.show;
end;
procedure TAPA_Application.HelpfilesAPAprogram1Click(Sender: TObject);
begin
APA_Help.show;
APA_Help.APABrowser.Navigate('C:\APADIR\Help\index.htm');
end;
procedure TAPA_Application.HelpfilesforMainmenu1Click(Sender: TObject);
begin
APA_Help.show;
APA_Help.APABrowser.Navigate('C:\APADIR\Help\APA_Mainmenu.htm');
end;
procedure TAPA_Application.FormCreate(Sender: TObject);
begin
CurrencyString:='';
ShortDateFormat:='dd.mm.yyyy';
LongDateFormat:='dd.mm.yyyy';
DateSeparator := '.';
ThousandSeparator:='.';
DecimalSeparator:=',';
CurrencyDecimals:=2;
ShortTimeFormat:='hh:nn';
LongTimeFormat:='hh:nn';
end;
end.
12.1.6
UNIT APA_DIALOGUNIT.DFM
object APA_Screen: TAPA_Screen
Left = 220
Top = 114
Width = 696
Height = 480
Caption = 'APA_Screen'
Color = clBtnFace
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -11
Font.Name = 'MS Sans Serif'
Font.Style = []
OldCreateOrder = False
Position = poScreenCenter
PixelsPerInch = 96
TextHeight = 13
12.1.7
ENDUNIT APA_DIALOGUNIT.PAS
unit APA_Dialogunit;
interface
uses
- 282 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, Buttons, ExtCtrls;
type
TAPA_Dialog = class(TForm)
APA_Text: TLabel;
Panel1: TPanel;
BitBtn1: TBitBtn;
BitBtn2: TBitBtn;
procedure Button1Click(Sender:
procedure Button2Click(Sender:
procedure BitBtn1Click(Sender:
procedure BitBtn2Click(Sender:
private
{ Private-Deklarationen }
public
{ Public-Deklarationen }
end;
TObject);
TObject);
TObject);
TObject);
var
APA_Dialog: TAPA_Dialog;
implementation
{$R *.dfm}
procedure TAPA_Dialog.Button1Click(Sender: TObject);
begin
Close;
end;
procedure TAPA_Dialog.Button2Click(Sender: TObject);
begin
Close;
end;
procedure TAPA_Dialog.BitBtn1Click(Sender: TObject);
begin
Modalresult:=mrYes;
end;
procedure TAPA_Dialog.BitBtn2Click(Sender: TObject);
begin
Modalresult:=mrNo;
end;
end.
12.1.8
UNIT APA_GRIDUNIT.DFM
object APA_Grid: TAPA_Grid
Left = 12
Top = 147
Width = 909
Height = 541
Caption = 'APA Grid'
Color = clBtnFace
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -11
Font.Name = 'MS Sans Serif'
Font.Style = []
Menu = APAGridMenu
OldCreateOrder = False
Position = poScreenCenter
OnShow = FormShow
PixelsPerInch = 96
TextHeight = 13
object APAGrid: TDrawGrid
Left = 1
- 283 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Top = 65
Width = 900
Height = 381
Align = alClient
ColCount = 1
DefaultDrawing = False
FixedCols = 0
RowCount = 1
FixedRows = 0
Options = []
PopupMenu = Gridpopup
TabOrder = 0
OnClick = APAGridClick
OnDblClick = APAGridDblClick
OnDrawCell = APAGridDrawCell
OnMouseDown = APAGridMouseDown
OnMouseMove = APAGridMouseMove
OnMouseWheelDown = APAGridMouseWheelUp
OnMouseWheelUp = APAGridMouseWheelUp
end
object Panel1: TPanel
Left = 0
Top = 0
Width = 901
Height = 41
Align = alTop
TabOrder = 1
OnDblClick = Panel1DblClick
object Button_remove_materialized_cubes: TButton
Left = 8
Top = 8
Width = 151
Height = 25
Caption = 'Remove materialized cubes'
TabOrder = 0
OnClick = Button_remove_materialized_cubesClick
end
object Button_remove_derivatives: TButton
Left = 168
Top = 8
Width = 151
Height = 25
Caption = 'Remove derivatives'
TabOrder = 1
OnClick = Button_remove_derivativesClick
end
object Button_remove_required_cubes: TButton
Left = 328
Top = 8
Width = 151
Height = 25
Caption = 'Remove required cubes'
TabOrder = 2
OnClick = Button_remove_required_cubesClick
end
object Remove_Redundancy: TCheckBox
Left = 488
Top = 8
Width = 145
Height = 23
Caption = 'Remove redundancy'
TabOrder = 3
OnClick = Remove_RedundancyClick
end
object Button1: TButton
Left = 616
Top = 8
Width = 41
Height = 25
Caption = 'Prosser'
TabOrder = 4
Visible = False
OnClick = Button1Click
end
- 284 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
object Button2: TButton
Left = 664
Top = 8
Width = 33
Height = 25
Caption = 'Tom'
TabOrder = 5
Visible = False
OnClick = Button2Click
end
object Button3: TButton
Left = 704
Top = 8
Width = 49
Height = 25
Caption = 'Richtig'
TabOrder = 6
Visible = False
OnClick = Button3Click
end
object Button4: TButton
Left = 760
Top = 8
Width = 49
Height = 25
Caption = 'Richtig2'
TabOrder = 7
Visible = False
OnClick = Button4Click
end
end
object Panel2: TPanel
Left = 0
Top = 446
Width = 901
Height = 41
Align = alBottom
TabOrder = 2
object Button_to_Input_Screen: TButton
Left = 16
Top = 8
Width = 152
Height = 25
Caption = 'Back to Input Screen'
ModalResult = 3
TabOrder = 0
OnClick = Button_to_Input_ScreenClick
end
object Button_to_Selection_Screen: TButton
Left = 176
Top = 8
Width = 152
Height = 25
Caption = 'APA Selection Screen'
ModalResult = 4
TabOrder = 1
OnClick = Button_to_Selection_ScreenClick
end
object Button_to_Main_Menu: TButton
Left = 336
Top = 8
Width = 152
Height = 25
Caption = 'Back to Main Menu'
TabOrder = 2
OnClick = Button_to_Main_MenuClick
end
end
object StatusBar: TStatusBar
Left = 0
Top = 41
Width = 901
Height = 24
Align = alTop
- 285 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Panels = <>
end
object Panel3: TPanel
Left = 0
Top = 65
Width = 1
Height = 381
Align = alLeft
Caption = 'Panel3'
TabOrder = 4
object ListBox1: TListBox
Left = 1
Top = 42
Width = 998
Height = 338
Align = alClient
ItemHeight = 13
TabOrder = 0
Visible = False
OnDblClick = ListBox1DblClick
end
object Panel4: TPanel
Left = 1
Top = 1
Width = 998
Height = 41
Align = alTop
TabOrder = 1
object Button5: TButton
Left = 14
Top = 8
Width = 75
Height = 25
Caption = 'Close Window'
TabOrder = 0
OnClick = Button5Click
end
end
end
object Gridpopup: TPopupMenu
OnPopup = GridpopupPopup
Left = 248
Top = 224
object NoCubeselected1: TMenuItem
Caption = 'No cube selected'
end
object Redundantcube1: TMenuItem
Caption = 'This is a redundant cube'
Visible = False
end
object N3: TMenuItem
Caption = '-'
end
object Required1: TMenuItem
Caption = 'Required'
object Item1: TMenuItem
OnClick = Item1Click
end
object Item2: TMenuItem
Tag = 1
OnClick = Item1Click
end
object Item3: TMenuItem
Tag = 2
OnClick = Item1Click
end
object Item4: TMenuItem
Tag = 3
OnClick = Item1Click
end
object Item5: TMenuItem
Tag = 4
OnClick = Item1Click
end
- 286 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
object Item6: TMenuItem
Tag = 5
OnClick = Item1Click
end
object Item7: TMenuItem
Tag = 6
OnClick = Item1Click
end
object Item8: TMenuItem
Tag = 7
OnClick = Item1Click
end
object Item9: TMenuItem
Tag = 8
OnClick = Item1Click
end
object Item10: TMenuItem
Tag = 10
OnClick = Item1Click
end
object Item11: TMenuItem
Tag = 10
OnClick = Item1Click
end
object Item12: TMenuItem
Tag = 11
OnClick = Item1Click
end
object Item13: TMenuItem
Tag = 12
OnClick = Item1Click
end
object Item14: TMenuItem
Tag = 13
OnClick = Item1Click
end
object Item15: TMenuItem
Tag = 14
OnClick = Item1Click
end
end
object Notrequired1: TMenuItem
Caption = 'Not required'
GroupIndex = 1
OnClick = Notrequired1Click
end
object Materialize1: TMenuItem
Caption = 'Materialize'
GroupIndex = 1
OnClick = Materialize1Click
end
object Dematerialize1: TMenuItem
Caption = 'Dematerialize'
GroupIndex = 1
OnClick = Dematerialize1Click
end
object N2: TMenuItem
Caption = '-'
GroupIndex = 1
end
object Showderivatives1: TMenuItem
Caption = 'Show derivatives'
GroupIndex = 1
OnClick = Showderivatives1Click
end
object ShowRedundancyfreecube1: TMenuItem
Caption = 'Show redundancy free cube'
GroupIndex = 1
OnClick = ShowRedundancyfreecube1Click
end
object Showpossiblecubes1: TMenuItem
Caption = 'Show possible cubes'
GroupIndex = 1
OnClick = Showpossiblecubes1Click
- 287 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end
object Removepossiblecubes1: TMenuItem
Caption = 'Remove possible cubes'
GroupIndex = 1
Visible = False
OnClick = Removepossiblecubes1Click
end
object Showdeterministicsolution1: TMenuItem
Caption = 'Show deterministic solution'
GroupIndex = 1
OnClick = Showdeterministicsolution1Click
end
object Removedeterministicsolution1: TMenuItem
Caption = 'Remove deterministic solution'
GroupIndex = 1
OnClick = Removedeterministicsolution1Click
end
object N8: TMenuItem
Caption = '-'
GroupIndex = 1
end
object Heuristics2: TMenuItem
Caption = 'Heuristics'
GroupIndex = 1
object SearchusingThomasAchsheuristic2: TMenuItem
Caption = 'Search using Thomas Achs heuristic'
OnClick = SearchusingThomasAchsheuristic2Click
end
object Alogrithm1: TMenuItem
Caption = 'Alogrithm permutation'
OnClick = Alogrithm1Click
end
object AlgorithmKombination2: TMenuItem
Caption = 'Algorithm combination'
OnClick = AlgorithmKombination2Click
end
end
object BuildCubesinDatabase2: TMenuItem
Caption = 'Build cubes in database for star schema'
GroupIndex = 1
object GenerateCREATESQLStatements1: TMenuItem
Caption = 'Generate CREATE SQL-statements BFT and dimension tables'
OnClick = GenerateCREATESQLStatements1Click
end
end
object Buildcubesindatabaseforfactconstellationschema1: TMenuItem
Caption = 'Build cubes in database for fact constellation schema'
GroupIndex = 1
object GenerateCREATESQLStatementsBFTanddimensiontables1: TMenuItem
Caption = 'Generate CREATE SQL-statements BFT and dimension tables'
OnClick = GenerateCREATESQLStatementsBFTanddimensiontables1Click
end
object GenerateCREATESQLStatementsformaterializedcubes1: TMenuItem
Caption = 'Generate CREATE SQL-statements for materialized cubes'
OnClick = GenerateCREATESQLStatementsformaterializedcubes1Click
end
end
object GetSQLStatementtomaterializethisview1: TMenuItem
Caption = 'Get SQL statement to query this cube'
GroupIndex = 1
object starschema1: TMenuItem
Caption = 'star schema'
OnClick = starschema1Click
end
object factconstellationschema1: TMenuItem
Caption = 'fact constellation schema'
OnClick = factconstellationschema1Click
end
end
object N4: TMenuItem
Caption = '-'
GroupIndex = 1
end
object ShowAnalysewindow2: TMenuItem
- 288 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Caption = 'Show APA analyse window'
GroupIndex = 1
OnClick = ShowAnalysewindow2Click
end
object Showlistbox1: TMenuItem
Caption = 'Show protocoll window'
GroupIndex = 1
OnClick = Showlistbox1Click
end
object N11: TMenuItem
Caption = '-'
GroupIndex = 1
end
object Showcosts1: TMenuItem
Caption = 'Show set random costs and limits left'
GroupIndex = 1
OnClick = Showcosts1Click
end
object ShowSetcalculatedcostsandlimitsleft1: TMenuItem
Caption = 'Show set calculated costs and limits left'
GroupIndex = 1
OnClick = ShowSetcalculatedcostsandlimitsleft1Click
end
object N6: TMenuItem
Caption = '-'
GroupIndex = 1
end
object Getrandomcosts1: TMenuItem
Caption = 'Get random costs'
GroupIndex = 1
object GetbuildBFT2: TMenuItem
Caption = 'Get build from BFT'
GroupIndex = 1
OnClick = GetbuildBFT2Click
end
object GetbuildParent2: TMenuItem
Caption = 'Get build from Parent'
GroupIndex = 1
OnClick = GetbuildParent2Click
end
object N9: TMenuItem
Caption = '-'
GroupIndex = 1
end
object GetQueryBFT2: TMenuItem
Caption = 'Get query from BFT'
GroupIndex = 1
OnClick = GetQueryBFT2Click
end
object GetQueryParent2: TMenuItem
Caption = 'Get Query from Parent'
GroupIndex = 1
OnClick = GetQueryParent2Click
end
end
object Getcalculatedcosts1: TMenuItem
Caption = 'Get calculated costs'
GroupIndex = 1
object GetbuildBFT1: TMenuItem
Caption = 'Get build from BFT'
OnClick = GetbuildBFT1Click
end
object Getbuildfromparent1: TMenuItem
Caption = 'Get build from parent'
OnClick = Getbuildfromparent1Click
end
object N1: TMenuItem
Caption = '-'
end
object GetqueryfromBFT1: TMenuItem
Caption = 'Get query from BFT'
OnClick = GetqueryfromBFT1Click
end
object Getqueryfromparent1: TMenuItem
- 289 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Caption = 'Get query from parent'
OnClick = Getqueryfromparent1Click
end
end
object Getmaterialisationspaceofcube1: TMenuItem
Caption = 'Get materialisation space of cube'
GroupIndex = 1
OnClick = Getmaterialisationspaceofcube1Click
end
object ShowData1: TMenuItem
Caption = 'Show data of cube'
GroupIndex = 1
OnClick = ShowData1Click
end
end
object langbezpopup: TPopupMenu
Left = 104
Top = 272
object langbez1: TMenuItem
Caption = 'langbez'
end
end
object privatmenu: TPopupMenu
Left = 760
Top = 144
object ShowButtons1: TMenuItem
Caption = 'Show Buttons'
OnClick = ShowButtons1Click
end
object ProssernurersterLauf1: TMenuItem
AutoCheck = True
Caption = 'Prosser nur erster Lauf'
Checked = True
end
object Minusnehmen1: TMenuItem
AutoCheck = True
Caption = 'Minus nehmen'
Checked = True
end
object tomohnederivate1: TMenuItem
AutoCheck = True
Caption = 'Tom ohne derivate'
end
object RechneThomas1: TMenuItem
AutoCheck = True
Caption = 'Rechne Thomas'
Checked = True
end
object ClearDatabase1: TMenuItem
Caption = 'Clear Database'
end
object Alwaysspacemaxbeachten1: TMenuItem
AutoCheck = True
Caption = 'Alwaysspacemax beachten'
Checked = True
end
end
object APAGridMenu: TMainMenu
Left = 376
Top = 184
object Actions1: TMenuItem
Caption = 'Actions'
object Removematerializedcubes1: TMenuItem
Caption = 'Remove materialized cubes'
OnClick = Removematerializedcubes1Click
end
object Removederivatives1: TMenuItem
Caption = 'Remove derivatives'
OnClick = Removederivatives1Click
end
object Removerequiredcubes1: TMenuItem
Caption = 'Remove required cubes'
OnClick = Removerequiredcubes1Click
end
- 290 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end
object Heuristics1: TMenuItem
Caption = 'Heuristics && Algorithms'
object SearchusingProsserheuristic1: TMenuItem
Caption = 'Search using Prosser heuristic'
Visible = False
end
object SearchusingThomasAchsheuristic1: TMenuItem
Caption = 'Search using Thomas Achs heuristic'
OnClick = SearchusingThomasAchsheuristic1Click
end
object Algorithm1: TMenuItem
Caption = 'Algorithm permutation'
OnClick = Algorithm1Click
end
object AlgorithmKombination1: TMenuItem
Caption = 'Algorithm combination'
OnClick = AlgorithmKombination1Click
end
object N7: TMenuItem
Caption = '-'
end
object AnalyseAPA1: TMenuItem
Caption = 'Show APA analyse window'
OnClick = AnalyseAPA1Click
end
object ShowAnalyseWindow1: TMenuItem
Caption = 'Show protocoll window'
OnClick = ShowAnalyseWindow1Click
end
object Showcosts2: TMenuItem
Caption = 'Show Set costs and limits left'
OnClick = Showcosts2Click
end
object Showsetcalculatedcostsandlimitsleft2: TMenuItem
Caption = 'Show set calculated costs and limits left'
end
object N10: TMenuItem
Caption = '-'
end
object Showpossiblecubes2: TMenuItem
Caption = 'Show possible cubes'
OnClick = Showpossiblecubes2Click
end
object Removepossiblecubes2: TMenuItem
Caption = 'Remove possible cubes'
Visible = False
OnClick = Removepossiblecubes2Click
end
object Showdeterministicsolution2: TMenuItem
Caption = 'Show deterministic solution'
OnClick = Showdeterministicsolution2Click
end
object Removedeterministicsolution2: TMenuItem
Caption = 'Remove deterministic solution'
Visible = False
OnClick = Removedeterministicsolution2Click
end
end
object BuildCubesinDatabase1: TMenuItem
Caption = 'Build Cubes in Database'
object GenerateCREATESQLStatementsforStarSchema1: TMenuItem
Caption = 'Generate CREATE SQL-statements for star schema'
object GenerateCREATESQLStatementsBFTanddimensiontables3: TMenuItem
Caption = 'Generate CREATE SQL-statements BFT and dimension tables'
OnClick = GenerateCREATESQLStatementsBFTanddimensiontables3Click
end
end
object GenerateCREATESQLStatementsforfactconstellationschema1: TMenuItem
Caption = 'Generate CREATE SQL-statements for fact constellation schema'
object GenerateCREATESQLStatementsBFTanddimensiontables2: TMenuItem
Caption = 'Generate CREATE SQL-statements BFT and dimension tables'
OnClick = GenerateCREATESQLStatementsBFTanddimensiontables2Click
end
- 291 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
object GenerateCREATESQLStatementsformaterializedcubes2: TMenuItem
Caption = 'Generate CREATE SQL-statements for materialized cubes'
OnClick = GenerateCREATESQLStatementsformaterializedcubes2Click
end
end
end
object Randomcosts1: TMenuItem
Caption = 'Random costs'
object Buildrandomcosts1: TMenuItem
Caption = 'Build random costs'
OnClick = Buildrandomcosts1Click
end
object Showrandomcosts1: TMenuItem
Caption = 'Show random costs'
OnClick = Showrandomcosts1Click
end
object Restrictedcosts1: TMenuItem
AutoCheck = True
Caption = 'Restricted costs'
Checked = True
OnClick = Restrictedcosts1Click
end
end
object Settings1: TMenuItem
Caption = 'Settings'
object Userandomcosts1: TMenuItem
AutoCheck = True
Caption = 'Use random costs'
Checked = True
end
object Removeredundancy1: TMenuItem
Caption = 'Remove redundancy'
OnClick = Removeredundancy1Click
end
object N5: TMenuItem
Caption = '-'
end
object Parameter1: TMenuItem
Caption = 'Parameters'
OnClick = Parameter1Click
end
object Options1: TMenuItem
Caption = 'Options'
OnClick = Options1Click
end
end
object Help1: TMenuItem
Caption = 'Help'
object HelpforAPAGridScreen1: TMenuItem
Caption = 'Help for APA Grid Screen'
OnClick = HelpforAPAGridScreen1Click
end
object HelpforAPAProgram1: TMenuItem
Caption = 'Help for APA Program'
OnClick = HelpforAPAProgram1Click
end
end
end
end
12.1.9
UNIT APA_GRIDUNIT.PAS
unit APA_Gridunit;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, ComCtrls, Menus, StdCtrls, ExtCtrls, Grids, Math;
type
TAPA_Grid = class(TForm)
- 292 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
APAGrid: TDrawGrid;
Panel1: TPanel;
Button_remove_materialized_cubes: TButton;
Button_remove_derivatives: TButton;
Button_remove_required_cubes: TButton;
Remove_Redundancy: TCheckBox;
Button1: TButton;
Button2: TButton;
Panel2: TPanel;
Button_to_Input_Screen: TButton;
Button_to_Selection_Screen: TButton;
Button_to_Main_Menu: TButton;
Gridpopup: TPopupMenu;
Redundantcube1: TMenuItem;
N3: TMenuItem;
Required1: TMenuItem;
Item1: TMenuItem;
Item2: TMenuItem;
Item3: TMenuItem;
Notrequired1: TMenuItem;
Materialize1: TMenuItem;
Dematerialize1: TMenuItem;
N2: TMenuItem;
Showderivatives1: TMenuItem;
ShowRedundancyfreecube1: TMenuItem;
Showlistbox1: TMenuItem;
langbezpopup: TPopupMenu;
langbez1: TMenuItem;
privatmenu: TPopupMenu;
ProssernurersterLauf1: TMenuItem;
StatusBar: TStatusBar;
Minusnehmen1: TMenuItem;
Item4: TMenuItem;
Item5: TMenuItem;
Item6: TMenuItem;
Item7: TMenuItem;
Item8: TMenuItem;
Item9: TMenuItem;
Item10: TMenuItem;
Item11: TMenuItem;
Item12: TMenuItem;
Item13: TMenuItem;
Item14: TMenuItem;
Item15: TMenuItem;
APAGridMenu: TMainMenu;
Actions1: TMenuItem;
Settings1: TMenuItem;
Removematerializedcubes1: TMenuItem;
Removederivatives1: TMenuItem;
Removerequiredcubes1: TMenuItem;
Userandomcosts1: TMenuItem;
Removeredundancy1: TMenuItem;
BuildCubesinDatabase1: TMenuItem;
Heuristics1: TMenuItem;
SearchusingProsserheuristic1: TMenuItem;
SearchusingThomasAchsheuristic1: TMenuItem;
tomohnederivate1: TMenuItem;
Button3: TButton;
RechneThomas1: TMenuItem;
Algorithm1: TMenuItem;
Heuristics2: TMenuItem;
SearchusingThomasAchsheuristic2: TMenuItem;
Alogrithm1: TMenuItem;
N4: TMenuItem;
BuildCubesinDatabase2: TMenuItem;
GenerateCREATESQLStatements1: TMenuItem;
NoCubeselected1: TMenuItem;
N5: TMenuItem;
Parameter1: TMenuItem;
Showcosts1: TMenuItem;
Button4: TButton;
Options1: TMenuItem;
N6: TMenuItem;
ShowData1: TMenuItem;
- 293 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Panel3: TPanel;
ListBox1: TListBox;
Panel4: TPanel;
Button5: TButton;
AlgorithmKombination1: TMenuItem;
AlgorithmKombination2: TMenuItem;
Getrandomcosts1: TMenuItem;
GetbuildBFT2: TMenuItem;
GetbuildParent2: TMenuItem;
N9: TMenuItem;
GetQueryBFT2: TMenuItem;
GetQueryParent2: TMenuItem;
ClearDatabase1: TMenuItem;
Randomcosts1: TMenuItem;
Buildrandomcosts1: TMenuItem;
Showrandomcosts1: TMenuItem;
N7: TMenuItem;
Showcosts2: TMenuItem;
N8: TMenuItem;
ShowAnalyseWindow1: TMenuItem;
AnalyseAPA1: TMenuItem;
ShowAnalysewindow2: TMenuItem;
Showpossiblecubes1: TMenuItem;
Removepossiblecubes1: TMenuItem;
Showpossiblecubes2: TMenuItem;
Removepossiblecubes2: TMenuItem;
Getmaterialisationspaceofcube1: TMenuItem;
ShowButtons1: TMenuItem;
GetSQLStatementtomaterializethisview1: TMenuItem;
Getcalculatedcosts1: TMenuItem;
GetbuildBFT1: TMenuItem;
Getbuildfromparent1: TMenuItem;
N1: TMenuItem;
GetqueryfromBFT1: TMenuItem;
Getqueryfromparent1: TMenuItem;
ShowSetcalculatedcostsandlimitsleft1: TMenuItem;
Showsetcalculatedcostsandlimitsleft2: TMenuItem;
N10: TMenuItem;
Restrictedcosts1: TMenuItem;
Showdeterministicsolution1: TMenuItem;
Removedeterministicsolution1: TMenuItem;
Showdeterministicsolution2: TMenuItem;
Removedeterministicsolution2: TMenuItem;
Buildcubesindatabaseforfactconstellationschema1: TMenuItem;
GenerateCREATESQLStatementsformaterializedcubes1: TMenuItem;
GenerateCREATESQLStatementsBFTanddimensiontables1: TMenuItem;
GenerateCREATESQLStatementsforStarSchema1: TMenuItem;
GenerateCREATESQLStatementsforfactconstellationschema1: TMenuItem;
GenerateCREATESQLStatementsformaterializedcubes2: TMenuItem;
GenerateCREATESQLStatementsBFTanddimensiontables2: TMenuItem;
GenerateCREATESQLStatementsBFTanddimensiontables3: TMenuItem;
Alwaysspacemaxbeachten1: TMenuItem;
Help1: TMenuItem;
HelpforAPAGridScreen1: TMenuItem;
N11: TMenuItem;
HelpforAPAProgram1: TMenuItem;
starschema1: TMenuItem;
factconstellationschema1: TMenuItem;
procedure generate();
procedure Erzeugungsbericht1Click(Sender: TObject);
procedure APAGridDrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
procedure APAGridMouseMove(Sender: TObject; Shift: TShiftState; X,
Y: Integer);
procedure Showlistbox1Click(Sender: TObject);
procedure Materialize1Click(Sender: TObject);
procedure Notrequired1Click(Sender: TObject);
procedure Dematerialize1Click(Sender: TObject);
procedure Showderivatives1Click(Sender: TObject);
procedure APAGridDblClick(Sender: TObject);
procedure APAGridMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
procedure Button_to_Input_ScreenClick(Sender: TObject);
procedure Button_to_Selection_ScreenClick(Sender: TObject);
- 294 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
procedure Button_to_Main_MenuClick(Sender: TObject);
procedure Remove_RedundancyClick(Sender: TObject);
procedure ShowRedundancyfreecube1Click(Sender: TObject);
procedure Button_remove_required_cubesClick(Sender: TObject);
procedure Button_remove_derivativesClick(Sender: TObject);
procedure Button_remove_materialized_cubesClick(Sender: TObject);
procedure ListBox1DblClick(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure bezeichnungenholen();
procedure materialzeichnen;
function getbuild(vonspalte,vonzeile,zuspalte,zuzeile:longint):Extended;
function getquery(vonspalte,vonzeile,zuspalte,zuzeile:longint):Extended;
function auffuellen(st:string;anzahl:longint):string;
function gettupel(aktspalte,aktzeile:longint):Extended;
function
getgrouptupel(parentspalte,parentzeile,aktspalte,aktzeile:longint):Extended;
function deltaBftW(aktspalte,aktzeile:longint;Query:boolean):Extended;
function deltaVW(spalte,zeile,aktspalte,aktzeile:longint;query:boolean):Extended;
function GetMinDerivatOfSpalte(aktspalte,aktzeile:longint;Query:boolean):longint;
function GetMinDerivatOfZeile(aktspalte,aktzeile:longint;Query:boolean):longint;
procedure berechneProsser();
procedure Button1Click(Sender: TObject);
function isderivat(spaltev,zeilev,spaltew,zeilew:longint):boolean;
procedure Item1Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
procedure APAGridClick(Sender: TObject);
procedure GridpopupPopup(Sender: TObject);
procedure Removematerializedcubes1Click(Sender: TObject);
procedure Removederivatives1Click(Sender: TObject);
procedure Removerequiredcubes1Click(Sender: TObject);
procedure Removeredundancy1Click(Sender: TObject);
procedure Button3Click(Sender: TObject);
procedure Algorithm1Click(Sender: TObject);
procedure SearchusingThomasAchsheuristic2Click(Sender: TObject);
procedure Alogrithm1Click(Sender: TObject);
procedure Parameter1Click(Sender: TObject);
function
berechneKostenGesamt(MatCubes,ReqCubes:TStringList;Nullstellen:boolean):Extended;
procedure Showcosts1Click(Sender: TObject);
function GetRightOrdertom(Listecubes:TStringList):TStringList;
procedure Button4Click(Sender: TObject);
procedure Options1Click(Sender: TObject);
procedure ShowData1Click(Sender: TObject);
procedure Button5Click(Sender: TObject);
procedure AlgorithmKombination1Click(Sender: TObject);
procedure AlgorithmKombination2Click(Sender: TObject);
procedure GetbuildBFT2Click(Sender: TObject);
procedure GetbuildParent2Click(Sender: TObject);
procedure GetQueryBFT2Click(Sender: TObject);
procedure GetQueryParent2Click(Sender: TObject);
procedure GenerateCREATESQLStatements1Click(Sender: TObject);
procedure SearchusingThomasAchsheuristic1Click(Sender: TObject);
procedure Panel1DblClick(Sender: TObject);
procedure Buildrandomcosts1Click(Sender: TObject);
procedure Showrandomcosts1Click(Sender: TObject);
procedure Showcosts2Click(Sender: TObject);
procedure ShowAnalyseWindow1Click(Sender: TObject);
procedure AnalyseAPA1Click(Sender: TObject);
procedure ShowAnalysewindow2Click(Sender: TObject);
procedure Showpossiblecubes1Click(Sender: TObject);
procedure Removepossiblecubes1Click(Sender: TObject);
procedure Showpossiblecubes2Click(Sender: TObject);
procedure Removepossiblecubes2Click(Sender: TObject);
procedure Getmaterialisationspaceofcube1Click(Sender: TObject);
procedure ShowButtons1Click(Sender: TObject);
procedure GetbuildBFT1Click(Sender: TObject);
procedure GetqueryfromBFT1Click(Sender: TObject);
procedure Getbuildfromparent1Click(Sender: TObject);
procedure Getqueryfromparent1Click(Sender: TObject);
procedure ShowSetcalculatedcostsandlimitsleft1Click(Sender: TObject);
procedure Restrictedcosts1Click(Sender: TObject);
procedure Showdeterministicsolution2Click(Sender: TObject);
procedure Showdeterministicsolution1Click(Sender: TObject);
procedure Removedeterministicsolution1Click(Sender: TObject);
- 295 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
procedure Removedeterministicsolution2Click(Sender: TObject);
procedure GenerateCREATESQLStatementsBFTanddimensiontables3Click(
Sender: TObject);
procedure GenerateCREATESQLStatementsformaterializedcubes2Click(
Sender: TObject);
procedure GenerateCREATESQLStatementsBFTanddimensiontables2Click(
Sender: TObject);
procedure GenerateCREATESQLStatementsBFTanddimensiontables1Click(
Sender: TObject);
procedure GenerateCREATESQLStatementsformaterializedcubes1Click(
Sender: TObject);
procedure APAGridMouseWheelUp(Sender: TObject; Shift: TShiftState;
MousePos: TPoint; var Handled: Boolean);
procedure HelpforAPAGridScreen1Click(Sender: TObject);
procedure HelpforAPAProgram1Click(Sender: TObject);
procedure factconstellationschema1Click(Sender: TObject);
procedure starschema1Click(Sender: TObject);
private
{ Private-Deklarationen }
public
{ Public-Deklarationen }
end;
type
TAPAField = record
linieoben:boolean;
linieunten:boolean;
linierechts:boolean;
linielinks:boolean;
dickoben:boolean;
dickunten:boolean;
dickrechts:boolean;
dicklinks:boolean;
farbe:TColor;
interessant:boolean;
materalisieren:boolean;
matcount:longint;//Gibt die Reihenfolge der Materialisierung an
derivative:boolean;
langbez:array of String;
kurzbez:String;
screenbez:String;
counthier:longint;//Gibt die neue Hierarchiestufe an
countdimension:longint;//Gibt die Dimension an, welche erhöht wird
zeile:longint;
spalte:longint;
gewicht:Extended;
gewichtlevel:longint;
value:Extended;//Gibt den Speicherwert an
value2:Extended;//Gibt den zweiten Speicherwert an
hierstufe:array of longint; //Gibt die aktuelle Hierarchiestufe jeder Dimension an
flag:Extended;
end;
var
APA_Grid: TAPA_Grid;
APA: array of array of TAPAField;
{Das Gitter}
dk: array of array of String;
{Alle Kurzbezeichungen der Dimension x und der Hierarchie y}
dl: array of array of String;
{Alle Langbezeichnungen der Dimension x und der Hierarchie y}
countdaten: array of array of longint;
{Die Anzahl der Datensätze der Dimension x und der Hierarchie y}
anzd:longint;
{Anzahl der Dimensionen}
anzh: array of longint;
{Anzahl der Hierarchiestufen der Dimension x}
- 296 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
dimbez: array of String;
{Bezeichnung der Dimension x}
zellezeile:longint;
{Wert für die aktuelle Spalte im Gitter}
zellespalte:longint;
{Wert für die aktuelle Zeile im Gitter}
anzzeilen:longint;
{Anzahl Zeilen des APA gesamt}
anzspalten:longint;
{Anzahl der Spalten des APA gesamt}
maxh:longint;
{Maximale Anzahl der Hierarchiestufen einer Dimension}
{Gibt die Aktuellen Bildschirmkoordinaten der Mouse an}
aktx:longint;
akty:longint;
{Gibt die Zelle an, welche zuletzt angeklickt wurde}
klickspalte:longint= -1;
klickzeile:longint= -1;
gotoSelection:boolean=false;
gotoInput:boolean=false;
{Gibt an, ob die Bezeichnungen ok sind}
bezeichnungenkontrolliert:boolean;
matcount:longint=0;//Gibt den aktuellen Materialisierungszähler an
permutation:boolean=true;
implementation
uses APA_Selectionunit, APA_Parameterunit, APA_Input_Screenunit,
APA_Applicationunit, APA_Processunit, APA_Sqlunit, APA_Keyunit,
APA_Dialogunit, APA_Optionsunit, APA_Show_costsunit, APA_Helpunit;
{$R *.dfm}
type Memorycubestype=
record
nr:longint;
spalte:longint;
zeile:longint;
end;
var Memorywuerfel: TStringList; //Die Liste der ausgewählten Würfel//
MerkeListe:array of longint;
spaceleft, spaceleftfirstcubes,timeleft:Extended;
Memorycubes,MemoryReqCubes:array of Memorycubestype;
MemoryReqCubescount:longint;
function TAPA_Grid.isderivat(spaltev,zeilev,spaltew,zeilew:longint):boolean;
var counter:longint;
derivat:boolean;
begin;
//Überprüfe, ob w ein Derivat von v ist:
//Wenn alle Dimensionen von v eine Hierarchiestufe gleich oder höher
//als w haben > dann ist es ein Derivat.
derivat:=false;
try
//Standardmäßig ist es ein Derivat
derivat:=true;
for counter:=0 to anzd-1 do begin
//Sollte eine Dimension von w eine geringere Hierachie
//als v haben, kann w nicht aus v errechnet werden
- 297 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if APA[spaltew,zeilew].hierstufe[counter]<APA[spaltev,zeilev].hierstufe[counter] then
derivat:=false;
end;
finally
//Übergeben des Ergebnisses
if (APA[spaltev,zeilev].farbe<>clYellow)or(APA[spaltew,zeilew].farbe<>clYellow)
then derivat:=false;
Result:=derivat;
end;
end;
procedure TAPA_Grid.bezeichnungenholen;
var dimcounter, counter:longint;
curItem:TTreeNode;
merkecount:longint;
abort:boolean;
begin
anzd:=0;abort:=false;
APA_Grid.ListBox1.Clear;
with APA_Input_Screen do begin
APA_Grid.ListBox1.Items.Add('Feststellen der Anzahl der Dimensionen');
{********* Anzahl der Dimensionen feststellen}
if Eingabe.Items.GetFirstNode<>nil then begin
{Wenn überhaupt etwas eingetragen ist dann ...}
CurItem := Eingabe.Items.GetFirstNode;
while CurItem <> nil do
begin
if CurItem.HasChildren then anzd:=anzd+1;
CurItem := CurItem.GetNext;
end;
end;
{********* Anzahl der Dimensionen feststellen ENDE}
APA_Grid.ListBox1.Items.Add('Es wurden '+inttostr(anzd)+' Dimensionen festgestellt!');
APA_Grid.ListBox1.Items.Add('Erzeuge das Array zum Speichern der
Dimensionsbezeichnungen');
{Erzeuge das Array zum Speichern der Dimensionsbezeichnungen}
dimbez:=nil; {Zuerst alte Bezeichnungen löschen, falls vorhanden}
setlength(dimbez,anzd);
APA_Grid.ListBox1.Items.Add('Erzeuge das Array zum Speichern der Anzahl der
Hierarchiestufen pro Dimension '+inttostr(anzd));
{Erzeuge das Array zum Speichern der Anzahl der Hierarchiestufen pro Dimension}
anzh:=nil;
setlength(anzh,anzd);
APA_Grid.ListBox1.Items.Add('Erzeuge das Array zum Speichern der Langbezeichnungen mit
anzd Dimensionen '+inttostr(anzd));
{Erzeuge das Array zum Speichern der Langbezeichnungen mit anzd Dimensionen}
dl:=nil;
setlength(dl,anzd);
APA_Grid.ListBox1.Items.Add('Erzeuge das Array zum Speichern der Kurzbezeichnungen mit
anzd Dimensionen '+inttostr(anzd));
{Erzeuge das Array zum Speichern der Kurzbezeichnungen mit anzd Dimensionen}
dk:=nil;
setlength(dk,anzd);
APA_Grid.ListBox1.Items.Add('Erzeuge das Array zum Speichern der Datensatzanzahlen mit
anzd Dimensionen '+inttostr(anzd));
{Erzeuge das Array zum Speichern der Kurzbezeichnungen mit anzd Dimensionen}
countdaten:=nil;
setlength(countdaten ,anzd);
{Dimensionsbezeichnungen und Hierarchiebezeichnungen eintragen}
{ und die Anzahl der Hierarchiestufen für jede Dimension eintragen}
- 298 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if Eingabe.Items.GetFirstNode<>nil then begin
{Wenn überhaupt etwas eingetragen ist dann ...}
dimcounter:=0;
CurItem := Eingabe.Items.GetFirstNode;
while (CurItem <> nil)and(abort=false) do
begin
anzh[dimcounter]:=CurItem.Count;
dimbez[dimcounter]:=CurItem.Text;
APA_Grid.ListBox1.Items.Add('****************************');
APA_Grid.ListBox1.Items.Add('Die Dimension '+dimbez[dimcounter]+'
'+inttostr(dimcounter)+' hat '+inttostr(anzh[dimcounter])+' Hierarchiestufen');
APA_Grid.ListBox1.Items.Add('Anzahl der Kurzbezeichnungen dieser Dimension festlegen
mit '+inttostr(anzh[dimcounter]));
{Anzahl der Kurzbezeichnungen dieser Dimension festlegen}
setlength(dk[dimcounter],anzh[dimcounter]);
APA_Grid.ListBox1.Items.Add('Anzahl der Langbezeichnungen dieser Dimension festlegen
mit '+inttostr(anzh[dimcounter]));
{Anzahl der Langbezeichnungen dieser Dimension festlegen}
setlength(dl[dimcounter],anzh[dimcounter]);
APA_Grid.ListBox1.Items.Add('Anzahl der Countdaten dieser Dimension festlegen mit
'+inttostr(anzh[dimcounter]));
{Anzahl der Langbezeichnungen dieser Dimension festlegen}
setlength(countdaten[dimcounter],anzh[dimcounter]);
CurItem:=CurItem.GetNext;
counter:=0;merkecount:=0;
while (CurItem <> nil)and(CurItem.HasChildren=false)and(abort=false) do
begin
{Eintragen der Kurzbezeichnung}
dk[dimcounter,counter]:=
copy(CurItem.Text,1,pos('//',CurItem.Text)-1);
APA_Grid.ListBox1.Items.Add('dk['+inttostr(dimcounter)+','+inttostr(counter)+']
Kurzbezeichnung '+dk[dimcounter,counter]+' eingetragen');
{Eintragen der Langbezeichnung}
dl[dimcounter,counter]:=
copy(CurItem.Text,pos('//',CurItem.Text)+2,pos('::',CurItem.Text)(pos('//',CurItem.Text)+2));
APA_Grid.ListBox1.Items.Add('dl['+inttostr(dimcounter)+','+inttostr(counter)+']
Langbezeichnung '+dl[dimcounter,counter]+' eingetragen');
{Eintragen der Countdaten}
countdaten[dimcounter,counter]:=
strtoint(copy(CurItem.Text,pos('::',CurItem.Text)+2,255));
APA_Grid.ListBox1.Items.Add('countdaten['+inttostr(dimcounter)+','+inttostr(counte
r)+'] Countdaten '+inttostr(countdaten[dimcounter,counter])+' eingetragen');
{Feststellen, ob die Anzahl der Datensätze größer ist als der Vorgänger}
if (countdaten[dimcounter,counter]>merkecount)and(merkecount<>0) then begin;
Showmessage('Error generating APA. Count of records in hierarchy
'+dk[dimcounter,counter]+' is larger than lower hierarchy. Abort Generation!');
abort:=true;
end;
{Setzen von merkecount}
merkecount:=countdaten[dimcounter,counter];
CurItem:=CurItem.GetNext;
counter:=counter+1;
end;
dimcounter:=dimcounter+1;
end;
end;
- 299 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
{********* Anzahl der Dimensionen feststellen ENDE}
if abort=false then bezeichnungenkontrolliert:=true;
end;
end;
function wuerfelvergleich (spalte,zeile:longint; akth:array of longint):boolean;
var derivat: array of longint;
g,x2:longint;
merk:boolean;
begin
//Bestimme die Hierarchiestufen der Dimensionen des materialisierten Elements
derivat:=nil;
setlength(derivat,anzd);
//Starte in Hierarchiestufe 0
for x2:=0 to anzd-1 do derivat[x2]:=0;
//Belege akthier mit der maximalen Hierarchiestufe jeder Dimension
for x2:=0 to spalte do
derivat[APA[x2,zeile].countdimension]:=APA[x2,zeile].counthier;
//Überprüfe, ob keine Hierarchiestufe der Dimension der aktuellen Zelle
// kleiner als die Hierarchiestufe der Dimension der materialisierten Würfel sind//
merk:=true;
for g:=0 to anzd-1 do begin
if (derivat[g]<akth[g]) then
merk:=false;
end;
Result:=merk;
end;
procedure markierederivative(spalte,zeile:longint);
var akth: array of longint;
counter:longint;
aktzeile, aktspalte:longint;
ende: boolean;
feld: array of boolean;
begin
//Diese Methode zeichnet die Linie für den zu materialisierenden Würfel//
//Bestimme die Hierarchiestufen der Dimension des mat. Elements//
akth:=nil;
setlength(akth,anzd);
//Alle Hierarchien starten in 0//
for counter:=0 to anzd-1 do akth[counter]:=0;
//Belege akthier mit der maximalen Hierarchiestufe jeder Dimension//
for counter:=0 to spalte do akth[
APA[counter,zeile].countdimension]:=APA[counter,zeile].counthier;
//Beginn in der ersten Zeile bestimmen
// Gehe dazu die Elemente der ersten Zeile von rechts nach links durch
// bis ein Würfel kein Derivat mehr ist. Dann setze den Cursor
//auf das letzte Element das ein Derivat ist.
aktzeile:=0;aktspalte:=anzspalten-1;ende:=false;
while (aktspalte>=0)and(ende=false) do begin
if wuerfelvergleich(aktspalte,aktzeile, akth)=false then begin
//Wenn kein Derivat
ende:=true;
//Spalte links vom Derivat mach eine rechte Linie
APA[aktspalte,aktzeile].linierechts:=true;
- 300 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
aktspalte:=aktspalte+1;
//im letzten Derivat mach eine linke Linie
APA[aktspalte,aktzeile].linielinks:=true;
end else aktspalte:=aktspalte-1;
end; {von while}
//Wenn die erste Zeile durchlaufen und ende ist immer noch false dann
// starte in der ersten Spalte von links
if (ende=false) then begin;
aktspalte:=0;
APA[aktspalte,aktzeile].linielinks:=true;
end;
//Der Cursor wandert zwischen den Zellen durch das Gitter.
// Die Positionsmarke des Cursors befindet sich immer in der linken
// unteren Ecke des Feldes.
//Das Programm kontrolliert die Zellen unterhalb.
// Feld[0] ist das Feld diagonal links untern.
// Feld[1] ist das Feld unmittelbar darunter.
//Setze beide Felder auf false
feld:=nil;
setlength(feld,2);
feld[0]:=false;
feld[1]:=false;
while(aktzeile<anzzeilen-1) do begin
//Kontrolliere alle 3 möglichen Zielfelder für den Cursor
feld[0]:=wuerfelvergleich(aktspalte,aktzeile+1,akth);
if (aktspalte<>0) then feld[1]:=wuerfelvergleich(aktspalte-1,aktzeile+1,akth)
else feld[1]:=false;
//Handle der Situation entsprechend
//Erster Fall Cursor nach untern
if (feld[0]=true)and(feld[1]=false) then begin
aktzeile:=aktzeile+1;
//Setze Linie links
APA[aktspalte,aktzeile].linielinks:=true;
if aktspalte<>0 then APA[aktspalte-1,aktzeile].linierechts:=true;
end;
//Zweiter Fall nach links
if (feld[0]=true)and(feld[1]=true) then begin
//Cursor nach links
aktspalte:=aktspalte-1;
//Setze Linie unten
APA[aktspalte,aktzeile].linieunten:=true;
//Setze Linie oben in der Zeile unterhalb
if (aktzeile+1<anzzeilen) then APA[aktspalte,aktzeile+1].linieoben:=true;
end;
//Dritter Fall nach rechts//
if (feld[0]=false)and(feld[1]=false) then begin
//Cursor nach rechts
//Setze Linie unten
APA[aktspalte,aktzeile].linieunten:=true;
//Setze Linie oben in der Zeile unterhalb
if (aktzeile+1<anzzeilen) then APA[aktspalte,aktzeile+1].linieoben:=true;
aktspalte:=aktspalte+1;
end;
end;{von while}
end;
- 301 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
procedure TAPA_Grid.materialzeichnen;
var spalte,zeile:longint;
ende:boolean;
begin
//Diese Methode zeichnet alle zu materialisierenden Würfel und zieht anschließend
// die dicke rote Begrenzungsinie.
//Alle Linien löschen
for spalte:= 0 to anzspalten-1 do begin
for zeile:=0 to anzzeilen-1 do begin
APA[spalte,zeile].linieoben:=false;
APA[spalte,zeile].linieunten:=false;
APA[spalte,zeile].linielinks:=false;
APA[spalte,zeile].linierechts:=false;
APA[spalte,zeile].derivative:=false;
APA[spalte,zeile].dickoben:=false;
APA[spalte,zeile].dickunten:=false;
APA[spalte,zeile].dicklinks:=false;
APA[spalte,zeile].dickrechts:=false;
end; //Ende von Zeilen
end; //Ende von Spalten
// Materialisiere alle Würfel, wo materailize = true
for spalte:= 0 to anzspalten-1 do begin
for zeile:=0 to anzzeilen-1 do begin
if APA[spalte,zeile].materalisieren=true then begin
markierederivative(spalte,zeile);
end;
end; //Ende von Zeilen
end; //Ende von Spalten
//Aussenlinie generieren
for zeile:= 0 to anzzeilen-1 do begin
ende:=false;
for spalte:=0 to anzspalten-1 do begin
if ende=false then begin
//Einfärben
if APA[spalte,zeile].linielinks=true then begin
//Line links
APA[spalte,zeile].dicklinks:=true;
ende:=true;
end else begin
//Line links links
APA[spalte,zeile].dickoben:=APA[spalte,zeile].linieoben;
APA[spalte,zeile].dickunten:=APA[spalte,zeile].linieunten;
APA[spalte,zeile].dicklinks:=APA[spalte,zeile].linielinks;
APA[spalte,zeile].dickrechts:=APA[spalte,zeile].linierechts;
//Wenn die unter Zeile nicht die letzte ist ziehe auch die
//untere Linie nach
if zeile<anzzeilen-1 then begin;
APA[spalte,zeile+1].dickoben:=APA[spalte,zeile+1].linieoben;
APA[spalte,zeile+1].dickunten:=false;
APA[spalte,zeile+1].dicklinks:=false;
APA[spalte,zeile+1].dickrechts:=false;
end;
//Wenn obere Zeile nicht außerhalb des Gitters ziehe
//auch die obere Linie nach
if (zeile>0) then
APA[spalte,zeile-1].dickunten:=APA[spalte,zeile-1].linieunten;
- 302 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end;
end;
end; //Ende von Zeilen
end; //Ende von Spalten
//Alle Linien löschen
for spalte:= 0 to anzspalten-1 do begin
for zeile:=0 to anzzeilen-1 do begin
APA[spalte,zeile].linieoben:=false;
APA[spalte,zeile].linieunten:=false;
APA[spalte,zeile].linielinks:=false;
APA[spalte,zeile].linierechts:=false;
APA[spalte,zeile].derivative:=false;
end; //Ende von Zeilen
end; //Ende von Spalten
end;
procedure ausfuellen(tozeile, tospalte, fromzeile,fromspalte, zeilemax:longint;
nachunten:boolean);
var zeile:longint;
begin
zeile:=tozeile;
if (nachunten=true) then begin
while (zeile<zeilemax) do begin
if (APA[tospalte,zeile].Screenbez='') then begin
APA[tospalte,zeile].Screenbez:=APA[fromspalte,fromzeile].Screenbez;
APA[tospalte,zeile].countdimension:=APA[fromspalte,fromzeile].countdimension;
APA[tospalte,zeile].counthier:=APA[fromspalte,fromzeile].counthier;
APA[tospalte,zeile].gewicht:=0;
APA[tospalte,zeile].gewichtlevel:=-1;
end;
zeile:=zeile+1;
end;
end else begin
{nach oben}
while (zeile>zeilemax) do begin
if (APA[tospalte,zeile].Screenbez='') then begin
APA[tospalte,zeile].Screenbez:=APA[fromspalte,fromzeile].Screenbez;
APA[tospalte,zeile].countdimension:=APA[fromspalte,fromzeile].countdimension;
APA[tospalte,zeile].counthier:=APA[fromspalte,fromzeile].counthier;
APA[tospalte,zeile].gewicht:=0;
APA[tospalte,zeile].gewichtlevel:=-1;
end;
zeile:=zeile-1;
end;
end;
end;
procedure zellenkop(fromx1,fromy1,fromx2,fromy2,tox,toy:longint; oben,mitfarbe:boolean);
var x,y:longint;
begin
{Kopiere die Zellen fromx1,formy1 bis fromx2,fromy2 auf die Zelle tox,toy und folgende}
if (oben=false) then toy:=toy-abs(fromy1-fromy2);
for x:=min(fromx1,fromx2) to max(fromx1,fromx2) do begin
for y:= min(fromy1,fromy2) to max(fromy1,fromy2) do begin
- 303 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
APA[tox-min(fromx1,fromx2)+x,toymin(fromy1,fromy2)+y].Screenbez:=APA[x,y].Screenbez;
if mitfarbe=true then
APA[tox-min(fromx1,fromx2)+x,toy-min(fromy1,fromy2)+y].farbe:=APA[x,y].farbe;
APA[tox-min(fromx1,fromx2)+x,toymin(fromy1,fromy2)+y].counthier:=APA[x,y].counthier;
APA[tox-min(fromx1,fromx2)+x,toymin(fromy1,fromy2)+y].countdimension:=APA[x,y].countdimension;
APA[tox-min(fromx1,fromx2)+x,toy-min(fromy1,fromy2)+y].gewicht:=0;
APA[tox-min(fromx1,fromx2)+x,toy-min(fromy1,fromy2)+y].gewichtlevel:=-1;
end;
end;
end;
procedure calculatecolumnscount;
var counter:longint;
begin
{Diese Procedure berechnet die Anzahl der Spalten des gesamten APA}
anzspalten:=0;
for counter:=0 to anzd-1 do anzspalten:=anzspalten+(anzh[counter]-1);
APA_Grid.ListBox1.Items.Add('Anzahl der Spalten des APAs berechnet mit
'+inttostr(anzspalten));
end;
procedure calculaterowcount;
var counter:longint;
begin
{Diese Procedure berechnet die Anzahl der Zeilen des gesamten APA}
anzzeilen:=1;
for counter:=0 to anzd-1 do begin;
if (anzh[counter]<>0) then anzzeilen:=anzzeilen*anzh[counter];
if (maxh<anzh[counter]) then maxh:=anzh[counter];
end;
anzzeilen:=round(anzzeilen/maxh);
APA_Grid.ListBox1.Items.Add('Anzahl der Zeilen des APAs berechnet mit
'+inttostr(anzzeilen));
end;
procedure generatedescriptions;
var zeile:longint;
akthier: array of longint;
s:String;
z,x:longint;
begin
APA_Grid.ListBox1.Items.Add('***********************');
APA_Grid.ListBox1.Items.Add('Generiere die Beschreibungen der Zellen');
for zeile:=0 to anzzeilen-1 do begin
APA_Grid.ListBox1.Items.Add('Generiere die Beschreibungen der Zeile '+inttostr(zeile));
akthier:=nil;
setlength(akthier,anzd);
s:='';
for z:=0 to anzd-1 do begin;akthier[z]:=0;end;
for x:=0 to anzspalten-1 do begin
akthier[APA[x,zeile].countdimension]:=APA[x,zeile].counthier;
//Kurzbezeichnung
s:='';
for z:=0 to anzd-1 do begin
s:=s+dk[z,akthier[z]];
if (z<>(anzd-1)) then s:=s+'; ';
- 304 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end;
APA[x,zeile].kurzbez:=s;
//Kurzbezeichnung generieren ENDE
//Langbezeichnung generieren
APA[x,zeile].langbez:=nil;
setlength(APA[x,zeile].langbez,anzd);
//Hierarchiestufenausprägungen generieren
APA[x,zeile].hierstufe:=nil;
setlength(APA[x,zeile].hierstufe,anzd);
for z:=0 to anzd-1 do begin
APA[x,zeile].langbez[z]:=dimbez[z]+':'+dl[z,akthier[z]];
APA[x,zeile].hierstufe[z]:=akthier[z];
end;
//Langbezeichnung generieren ENDE
end;
end;
end;
procedure TAPA_Grid.generate;
var zeile,spalte:longint;
var feld,dimcounter,hiercounter, counter:longint;
var aktuelledim,aktuellespalte,aktuellezeile,anzkop:longint;
begin
{APA erzeugen}
APA:=nil;
setlength(APA,anzspalten,anzzeilen);
{APA mit Werten füllen}
for zeile:=0 to anzzeilen-1 do begin
for spalte:=0 to anzspalten-1 do begin
APA[spalte,zeile].zeile:=zeile;
APA[spalte,zeile].spalte:=spalte;
APA[spalte,zeile].linieoben:=false;
APA[spalte,zeile].linieunten:=false;
APA[spalte,zeile].linielinks:=false;
APA[spalte,zeile].linierechts:=false;
APA[spalte,zeile].dickoben:=false;
APA[spalte,zeile].dickunten:=false;
APA[spalte,zeile].dicklinks:=false;
APA[spalte,zeile].dickrechts:=false;
APA[spalte,zeile].farbe:=clWhite;
APA[spalte,zeile].interessant:=false;
APA[spalte,zeile].materalisieren:=false;
APA[spalte,zeile].derivative:=false;
APA[spalte,zeile].Screenbez:='';
APA[spalte,zeile].kurzbez:='';
end;
end;
{Erste Zeile erzeugen}
feld:=0;
for dimcounter:=0 to anzd-1 do begin
for hiercounter:=1 to anzh[dimcounter]-1 do begin
APA[feld,0].Screenbez:=dk[dimcounter,hiercounter];
APA[feld,0].farbe:=clYellow;
APA[feld,0].counthier:=hiercounter;
APA[feld,0].countdimension:=dimcounter;
APA[feld,0].gewicht:=0;
APA[feld,0].gewichtlevel:=0;
feld:=feld+1;
end;
end;
- 305 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
{Kopieren der redundanzfreien Zellen des APA}
aktuelledim:=anzd-1;
aktuellespalte:=anzspalten-(anzh[aktuelledim]-1);
aktuellezeile:=0;
while (aktuellespalte>0) do begin
{Kopiere Block Beginn}
anzkop:=0;
while (anzkop<anzh[aktuelledim-1]-1) do begin
anzkop:=anzkop+1;
zellenkop(aktuellespalte,aktuellezeile,anzspalten-1,0,
aktuellespalte-anzkop,aktuellezeile+(anzkop*(aktuellezeile+1)),false,true);
end;
{Kopieren Block ENDE}
{Auffüllen des APA mit Redundanten Zellen}
for counter:=aktuellespalte-anzkop to aktuellespalte-1 do begin
ausfuellen(aktuellezeile+(anzkop*(aktuellezeile+1)),(anzspalten-1)+(counter(aktuellespalte-1)),0,counter,max(aktuellezeile-1,0),false);
end;
for counter:=aktuellespalte-anzkop to aktuellespalte do begin
ausfuellen(0,counter,0,counter,anzzeilen,true);
end;
{Setze aktuelle Zeile als die unterste bereits ausgefüllte Zeile}
aktuellezeile:=aktuellezeile+(anzkop*(aktuellezeile+1));
{Setze Spalte als Spalte in die der letzte Kopiervorgang vollzogen wurde}
aktuellespalte:=aktuellespalte-anzkop;
{Vermindere den Dimensionszähler}
aktuelledim:=aktuelledim-1;
end;
generatedescriptions;
APA_Selection_Screen.Req.Items.Clear;
APA_Selection_Screen.Listeint.Items.Clear;
Button_remove_materialized_cubesClick(self);
Removepossiblecubes1Click(self);
end;
procedure TAPA_Grid.Erzeugungsbericht1Click(Sender: TObject);
begin
listbox1.Width:=round(APA_Grid.Width/2);
listbox1.Visible:=true;
end;
procedure TAPA_Grid.APAGridDrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
var NewRect:TRect;
begin
APAGrid.Canvas.Brush.Color:=APA[ACol,ARow].farbe;
APAGrid.Canvas.FillRect(Rect);
//Gitterzeilen
APAGrid.Canvas.Brush.Color:=clLtGray;
APAGrid.Canvas.Pen.Color:=clLtGray;
APAGrid.Canvas.Rectangle(Rect.Left,Rect.Top,Rect.Right+1,Rect.top);
APAGrid.Canvas.Rectangle(Rect.Left,Rect.Bottom-1,Rect.Right+1,Rect.Bottom);
APAGrid.Canvas.Rectangle(Rect.Right-1,Rect.Top,Rect.Right,Rect.Bottom+1);
APAGrid.Canvas.Rectangle(Rect.Left,Rect.Top,Rect.Left,Rect.Bottom+1);
APAGrid.Canvas.Brush.Color:=APA[ACol,ARow].farbe;
if (APA[ACol,ARow].flag=1) then begin
- 306 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
NewRect.Left:=Rect.left;
NewRect.Right:=Rect.left+13;
NewRect.Top:=Rect.Bottom-13;
NewRect.Bottom:=Rect.Bottom;
APAGrid.Canvas.Brush.Color:=clBlack;
APAGrid.Canvas.FillRect(NewRect);
APAGrid.Canvas.Font.Color:=clWhite;
APAGrid.Canvas.Font.Size:=4;
APAGrid.Canvas.Font.Style:=[fsBold];
APAGrid.Canvas.TextOut(Rect.left+2,Rect.Bottom-11,'P');
APAGrid.Canvas.Font.Style:=[];
APAGrid.Canvas.Brush.Color:=APA[ACol,ARow].farbe;
APAGrid.Canvas.Font.Color:=clBlack;
APAGrid.Canvas.Pen.Color:=clBlack;
end;
if (APA[ACol,ARow].flag>=2)and(APA[ACol,ARow].flag<3) then begin
NewRect.Left:=Rect.left;
NewRect.Right:=Rect.left+13;
NewRect.Top:=Rect.Bottom-13;
NewRect.Bottom:=Rect.Bottom;
APAGrid.Canvas.Brush.Color:=clGreen;
APAGrid.Canvas.FillRect(NewRect);
APAGrid.Canvas.Font.Color:=clWhite;
APAGrid.Canvas.Font.Size:=4;
APAGrid.Canvas.Font.Style:=[];
APAGrid.Canvas.TextOut(Rect.left+2,Rect.Bottom-11,floattostr((APA[ACol,ARow].flag2)*10000));
APAGrid.Canvas.Font.Style:=[];
APAGrid.Canvas.Brush.Color:=APA[ACol,ARow].farbe;
APAGrid.Canvas.Font.Color:=clBlack;
APAGrid.Canvas.Pen.Color:=clBlack;
end;
if (APA[ACol,ARow].interessant=true) then begin
NewRect.Left:=Rect.Left;
NewRect.Right:=Rect.Left+14;
NewRect.Top:=Rect.Top;
NewRect.Bottom:=Rect.Top+14;
APAGrid.Canvas.Brush.Color:=DegreeColors[APA[ACol,ARow].gewichtlevel];
APAGrid.Canvas.FillRect(NewRect);
APAGrid.Canvas.Font.Color:=clWhite;
APAGrid.Canvas.Font.Size:=4;
APAGrid.Canvas.Font.Style:=[fsBold];
APAGrid.Canvas.TextOut(Rect.Left+2,Rect.Top+1,'R');
APAGrid.Canvas.Font.Style:=[];
APAGrid.Canvas.Brush.Color:=APA[ACol,ARow].farbe;
APAGrid.Canvas.Font.Color:=clBlack;
APAGrid.Canvas.Pen.Color:=clBlack;
end;
if (APA[ACol,ARow].linieoben=true) then begin
APAGrid.Canvas.Pen.Color:=clBlack;
APAGrid.Canvas.Brush.Color:=clBlack;
if (ACol<>0) then begin
if (APA[ACol-1,ARow].dickoben=true)or(APA[ACol,ARow].dicklinks=true) then
APAGrid.Canvas.Rectangle(Rect.Left+2,Rect.Top-2,Rect.Right+2,Rect.top+2)
else
APAGrid.Canvas.Rectangle(Rect.Left-2,Rect.Top-2,Rect.Right+2,Rect.top+2);
end else
APAGrid.Canvas.Rectangle(Rect.Left-2,Rect.Top-2,Rect.Right+2,Rect.top+2);
end;
- 307 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if (APA[ACol,ARow].linieunten=true) then begin
APAGrid.Canvas.Pen.Color:=clBlack;
APAGrid.Canvas.Brush.Color:=clBlack;
if (ACol<>0) then begin
if (APA[ACol-1,ARow].dickunten=true)or(APA[ACol,ARow].dicklinks=true) then
APAGrid.Canvas.Rectangle(Rect.Left+2,Rect.Bottom-2,Rect.Right+2,Rect.Bottom)
else
APAGrid.Canvas.Rectangle(Rect.Left-2,Rect.Bottom-2,Rect.Right+2,Rect.Bottom);
end else
APAGrid.Canvas.Rectangle(Rect.Left-2,Rect.Bottom-2,Rect.Right+2,Rect.Bottom);
end;
if (APA[ACol,ARow].linierechts=true) then begin
APAGrid.Canvas.Pen.Color:=clBlack;
APAGrid.Canvas.Brush.Color:=clBlack;
APAGrid.Canvas.Rectangle(Rect.Right-2,Rect.Top-2,Rect.Right,Rect.Bottom+2);
end;
if (APA[ACol,ARow].linielinks=true) then begin
APAGrid.Canvas.Pen.Color:=clBlack;
APAGrid.Canvas.Brush.Color:=clBlack;
APAGrid.Canvas.Rectangle(Rect.Left-2,Rect.Top-2,Rect.Left+2,Rect.Bottom+2);
end;
if (APA[ACol,ARow].dickoben=true) then begin
APAGrid.Canvas.Pen.Color:=clRed;
APAGrid.Canvas.Brush.Color:=clRed;
APAGrid.Canvas.Rectangle(Rect.Left-2,Rect.Top-2,Rect.Right+2,Rect.top+2);
end;
if (APA[ACol,ARow].dickunten=true) then begin
APAGrid.Canvas.Pen.Color:=clRed;
APAGrid.Canvas.Brush.Color:=clRed;
APAGrid.Canvas.Rectangle(Rect.Left-2,Rect.Bottom-2,Rect.Right+2,Rect.Bottom);
end;
if (APA[ACol,ARow].dickrechts=true) then begin
APAGrid.Canvas.Pen.Color:=clRed;
APAGrid.Canvas.Brush.Color:=clRed;
APAGrid.Canvas.Rectangle(Rect.Right-2,Rect.Top-2,Rect.Right,Rect.Bottom+2);
end;
if (APA[ACol,ARow].dicklinks=true) then begin
APAGrid.Canvas.Pen.Color:=clRed;
APAGrid.Canvas.Brush.Color:=clRed;
APAGrid.Canvas.Rectangle(Rect.Left-2,Rect.Top-2,Rect.Left+2,Rect.Bottom+2);
end;
if (ACol>0)and(ARow>0) then begin
if (APA[ACol-1,ARow].linieoben=true)or(APA[ACol,ARow-1].linielinks=true)
or (APA[ACol,ARow].linielinks=true) then begin
APAGrid.Canvas.Pen.Color:=clBlack;
APAGrid.Canvas.Brush.Color:=clBlack;
APAGrid.Canvas.Rectangle(Rect.Left-2,Rect.Top-2,Rect.Left+2,Rect.Top+2);
end;
if (APA[ACol-1,ARow].dickoben=true)or(APA[ACol,ARow-1].dicklinks=true)
or (APA[ACol,ARow].dicklinks=true) then begin
APAGrid.Canvas.Pen.Color:=clRed;
APAGrid.Canvas.Brush.Color:=clRed;
APAGrid.Canvas.Rectangle(Rect.Left-2,Rect.Top-2,Rect.Left+2,Rect.Top+2);
end;
end;
APAGrid.Canvas.Font.Size:=8;
APAGrid.Canvas.Brush.Color:=APA[ACol,ARow].farbe;
APAGrid.Canvas.Font.Color:=clBlack;
APAGrid.Canvas.Pen.Color:=clBlack;
- 308 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if (APA[ACol,ARow].materalisieren=true) then begin;
APAGrid.Canvas.Pen.Color:=clRed;
APAGrid.Canvas.Brush.Color:=clRed;
NewRect.Left:=Rect.Left+round((Rect.Right-Rect.Left)/6);
NewRect.Right:=Rect.Right-round((Rect.Right-Rect.Left)/6);
NewRect.Top:=Rect.Top+round((Rect.Bottom-Rect.Top)/6);
NewRect.Bottom:=Rect.Bottom-round((Rect.Bottom-Rect.Top)/6);
APAGrid.Canvas.Ellipse(NewRect);
APAGrid.Canvas.Font.Size:=4;
APAGrid.Canvas.Font.Color:=clWhite;
APAGrid.Canvas.Brush.Color:=clBlack;
if APA[ACol,ARow].matcount>9 then
APAGrid.Canvas.TextOut(Rect.Right-14,Rect.bottom15,inttostr(APA[ACol,ARow].matcount))
else
APAGrid.Canvas.TextOut(Rect.Right-8,Rect.bottom15,inttostr(APA[ACol,ARow].matcount));
APAGrid.Canvas.Font.Size:=8;
APAGrid.Canvas.Font.Color:=clWhite;
APAGrid.Canvas.Brush.Color:=clRed;
end;
if (APA[ACol,ARow].derivative=true) then begin;
APAGrid.Canvas.Pen.Color:=clGreen;
APAGrid.Canvas.Brush.Color:=clGreen;
NewRect.Left:=Rect.Left+round((Rect.Right-Rect.Left)/6);
NewRect.Right:=Rect.Right-round((Rect.Right-Rect.Left)/6);
NewRect.Top:=Rect.Top+round((Rect.Bottom-Rect.Top)/6);
NewRect.Bottom:=Rect.Bottom-round((Rect.Bottom-Rect.Top)/6);
APAGrid.Canvas.Ellipse(NewRect);
APAGrid.Canvas.Font.Size:=8;
APAGrid.Canvas.Font.Color:=clWhite;
end;
if (ACol=klickspalte)and(ARow=klickzeile) then begin;
APAGrid.Canvas.Pen.Color:=clBlue;
APAGrid.Canvas.Brush.Color:=clBlue;
NewRect.Left:=Rect.Left+round((Rect.Right-Rect.Left)/6);
NewRect.Right:=Rect.Right-round((Rect.Right-Rect.Left)/6);
NewRect.Top:=Rect.Top+round((Rect.Bottom-Rect.Top)/6);
NewRect.Bottom:=Rect.Bottom-round((Rect.Bottom-Rect.Top)/6);
APAGrid.Canvas.Ellipse(NewRect);
APAGrid.Canvas.Font.Size:=8;
APAGrid.Canvas.Font.Color:=clWhite;
end;
if (Remove_Redundancy.Checked=false)or
((Remove_Redundancy.Checked=true)and(APA[ACol,ARow].farbe=clYellow)) then
begin;
APAGrid.Canvas.TextOut(round((Rect.left+Rect.right)/2)round(APAGrid.Canvas.TextWidth(APA[ACol,Arow].Screenbez)/2),
round((Rect.top+Rect.Bottom)/2)round(APAGrid.Canvas.TextHeight(APA[ACol,Arow].Screenbez)/2),APA[ACol,Arow].Screen
bez);
end;
end;
procedure TAPA_Grid.APAGridMouseMove(Sender: TObject; Shift: TShiftState;
X, Y: Integer);
begin
aktx:=x;akty:=y;
zellespalte:=APAGrid.MouseCoord(x,y).X;
zellezeile:=APAGrid.MouseCoord(x,y).y;
- 309 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if ((zellespalte<>-1)and(zellezeile<>-1))
then begin;
if (Remove_Redundancy.Checked=false)or
((Remove_Redundancy.Checked=true)and(APA[zellespalte,zellezeile].farbe=clYellow)) then
begin;
if APA[zellespalte,zellezeile].interessant=true then begin
if (APA[zellespalte,zellezeile].gewichtlevel<>-1)
and(APA[zellespalte,zellezeile].gewichtlevel<APA_Parameter.APA_Degrees.Items.Count)
then
statusbar.SimpleText:='('+inttostr(zellespalte)+':'+inttostr(zellezeile)+'):'+APA[
zellespalte,zellezeile].kurzbez+' /Required:
'+APA_Parameter.APA_Degrees.Items[APA[zellespalte,zellezeile].gewichtlevel]
else
statusbar.SimpleText:='('+inttostr(zellespalte)+':'+inttostr(zellezeile)+'):'+APA[
zellespalte,zellezeile].kurzbez+' /Required:';
end
else
statusbar.SimpleText:='('+inttostr(zellespalte)+':'+inttostr(zellezeile)+'):'+APA[
zellespalte,zellezeile].kurzbez;
end else
statusbar.SimpleText:='Redundant cube selected';
{Generieren der Kurzbezeichnung}
end else
statusbar.SimpleText:='No cell selected';
end;
procedure TAPA_Grid.Showlistbox1Click(Sender: TObject);
begin
Panel3.Width:=round(APAGrid.Width/2);
listbox1.Visible:=true;
end;
procedure TAPA_Grid.Materialize1Click(Sender: TObject);
begin
mustsave:=true;
APA[zellespalte,zellezeile].materalisieren:=true;
matcount:=matcount+1;
APA[zellespalte,zellezeile].matcount:=matcount;
materialzeichnen;
APAgrid.Repaint;
end;
procedure TAPA_Grid.Notrequired1Click(Sender: TObject);
begin
mustsave:=true;
APA[zellespalte,zellezeile].interessant:=false;
APA[zellespalte,zellezeile].gewicht:=0;
APAGrid.Repaint;
end;
procedure TAPA_Grid.Dematerialize1Click(Sender: TObject);
var merke,zeile,spalte:longint;
begin
mustsave:=true;
APA[zellespalte,zellezeile].materalisieren:=false;
//Neu Nummerieren
merke:=APA[zellespalte,zellezeile].matcount;
APA[zellespalte,zellezeile].matcount:=0;
for zeile:=0 to anzzeilen-1 do begin
for spalte:=0 to anzspalten-1 do begin
if APA[spalte,zeile].matcount>merke then begin
APA[spalte,zeile].matcount:=APA[spalte,zeile].matcount-1;
end;
- 310 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end;//spalte
end;//zeile
matcount:=matcount-1;
materialzeichnen;
APAGrid.Repaint;
end;
procedure TAPA_Grid.Showderivatives1Click(Sender: TObject);
var spalte,zeile:longint;
begin
//Alle Linien löschen
for spalte:= 0 to anzspalten-1 do begin
for zeile:=0 to anzzeilen-1 do begin
APA[spalte,zeile].linieoben:=false;
APA[spalte,zeile].linieunten:=false;
APA[spalte,zeile].linielinks:=false;
APA[spalte,zeile].linierechts:=false;
APA[spalte,zeile].derivative:=false;
end; //Ende von Zeilen
end; //Ende von Spalten
APA[zellespalte,zellezeile].derivative:=true;
markierederivative(zellespalte,zellezeile);
APAGrid.Repaint;
end;
procedure TAPA_Grid.APAGridDblClick(Sender: TObject);
begin
APAGrid.Repaint;
end;
procedure TAPA_Grid.APAGridMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
begin
zellespalte:=APAGrid.MouseCoord(x,y).X;
zellezeile:=APAGrid.MouseCoord(x,y).y;
{klickspalte:=APAGrid.MouseCoord(x,y).X;
klickzeile:=APAGrid.MouseCoord(x,y).y;}
end;
procedure TAPA_Grid.Button_to_Input_ScreenClick(Sender: TObject);
begin
gotoInput:=true;
gotoSelection:=false;
APA_Grid.Close;
end;
procedure TAPA_Grid.Button_to_Selection_ScreenClick(Sender: TObject);
begin
gotoInput:=false;
gotoSelection:=true;
APA_Grid.Close;
end;
procedure TAPA_Grid.Button_to_Main_MenuClick(Sender: TObject);
begin
Close;
end;
procedure TAPA_Grid.Remove_RedundancyClick(Sender: TObject);
begin
Removeredundancy1.Checked:=Remove_Redundancy.Checked;
Apagrid.Repaint;
end;
procedure TAPA_Grid.ShowRedundancyfreecube1Click(Sender: TObject);
- 311 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
var spalte,zeile:longint;
begin
klickspalte:=zellespalte;klickzeile:=zellezeile;
spalte:=zellespalte;zeile:=zellezeile;
while (APA[klickspalte,klickzeile].kurzbez=APA[spalte,zeile].kurzbez)
and(APA[klickspalte,klickzeile].farbe<>clYellow) do begin
klickzeile:=klickzeile-1;if klickzeile<0 then exit;
end;
APAGrid.Repaint;
end;
procedure TAPA_Grid.Button_remove_required_cubesClick(Sender: TObject);
var zahler:longint;
zeile,spalte:longint;
begin
mustsave:=true;
zeile:=0;
while (zeile<anzzeilen)do begin
spalte:=0;
while (spalte<anzspalten) do begin
APA[spalte,zeile].interessant:=false;
APA[spalte,zeile].gewicht:=0;
spalte:=spalte+1;
end;
zeile:=zeile+1;
end;
with APA_Selection_Screen do begin
for zahler:=0 to Listeint.Items.Count-1 do begin
if (copy(Listeint.items[zahler],1,4)='Req:') then begin;
Req.Items[zahler].ImageIndex:=0;
Req.Items[zahler].SelectedIndex:=0;
end;
end;
end;
ApaGrid.Repaint;
end;
procedure TAPA_Grid.Button_remove_derivativesClick(Sender: TObject);
begin
mustsave:=true;
zellezeile:=0;
while (zellezeile<anzzeilen)do begin
zellespalte:=0;
while (zellespalte<anzspalten) do begin
APA[zellespalte,zellezeile].derivative:=false;
zellespalte:=zellespalte+1;
end;
zellezeile:=zellezeile+1;
end;
materialzeichnen;
ApaGrid.Repaint;
end;
procedure TAPA_Grid.Button_remove_materialized_cubesClick(Sender: TObject);
begin
mustsave:=true;
zellezeile:=0;
while (zellezeile<anzzeilen)do begin
zellespalte:=0;
while (zellespalte<anzspalten) do begin
APA[zellespalte,zellezeile].materalisieren:=false;
APA[zellespalte,zellezeile].value:=0;
zellespalte:=zellespalte+1;
end;
zellezeile:=zellezeile+1;
end;
materialzeichnen;
ApaGrid.Repaint;
- 312 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
matcount:=0;
end;
procedure TAPA_Grid.ListBox1DblClick(Sender: TObject);
begin
Panel3.Width:=1;
end;
procedure TAPA_Grid.FormShow(Sender: TObject);
begin
if generiereapaneu=true then begin
APAGrid.Visible:=false;
APAGrid.Enabled:=false;
{Spalten berechnen}
calculatecolumnscount;
{Anz der Zielen berechnen}
calculaterowcount;
APAGrid.ColCount:=anzspalten;
APAGrid.RowCount:=anzzeilen;
{APA generieren}
generate;
APAGrid.Visible:=true;
APAGrid.Enabled:=true;
generiereapaneu:=false;
Showdeterministicsolution2.Visible:=true;
Removedeterministicsolution2.Visible:=false;
end;
end;
function TAPA_Grid.getbuild(vonspalte,vonzeile,zuspalte,zuzeile:longint):Extended;
begin
with APA_Application do begin
if (vonspalte<>zuspalte)or(vonzeile<>zuzeile) then begin
if findkosten(vonspalte,vonzeile,zuspalte,zuzeile) then begin
Result:=vKosten.Build;
end//End of findkey
else begin;
if (vonspalte<>zuspalte)or(vonzeile<>zuzeile) then begin;
APA_Show_Process.ausgabe('Da fehlen Kosten!!
'+inttostr(vonspalte)+':'+inttostr(vonzeile)+'/'+inttostr(zuspalte)+':'+inttostr(z
uzeile));//Später entfernen
break:=true;
end;
Result:=0;
end;
end else Result:=0;
end;//End of APA_Application}
end;
function TAPA_Grid.getquery(vonspalte,vonzeile,zuspalte,zuzeile:longint):Extended;
begin
with APA_Application do begin
if (vonspalte<>zuspalte)or(vonzeile<>zuzeile) then begin
if findkosten(vonspalte,vonzeile,zuspalte,zuzeile) then begin
Result:=vKosten.Query;
end//End of findkey
else begin;
if (vonspalte<>zuspalte)or(vonzeile<>zuzeile) then begin;
- 313 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
APA_Show_Process.ausgabe('Da fehlen QueryKosten!!
'+inttostr(vonspalte)+':'+inttostr(vonzeile)+'/'+inttostr(zuspalte)+':'+inttostr(z
uzeile));//Später entfernen
break:=true;end;
Result:=0;
end;
end else Result:=0;
end;//End of APA_Application
end;
function TAPA_Grid.auffuellen(st:string; anzahl:longint):string;
begin
while (length(st)<anzahl) do begin
st:='0'+st;
end;
result:=st;
end;
function
TAPA_Grid.getgrouptupel(parentspalte,parentzeile,aktspalte,aktzeile:longint):Exten
ded;
var counter:longint;
var dimcount:longint;
begin;
if parentspalte<>-1 then begin
dimcount:=0;
for counter:=0 to anzd-1 do begin
if (APA[parentspalte,parentzeile].hierstufe[counter]<
APA[aktspalte,aktzeile].hierstufe[counter])and
(APA[aktspalte,aktzeile].hierstufe[counter]<>0) then begin
dimcount:=dimcount+1;
end;
end;
end//of -1
else begin
dimcount:=0;
for counter:=0 to anzd-1 do begin
if (APA[aktspalte,aktzeile].hierstufe[counter]<>0) then begin
dimcount:=dimcount+1
end;
end;
end;
Result:=dimcount;
end;
function TAPA_Grid.gettupel(aktspalte,aktzeile:longint):Extended;
var storetupels:Extended;
var anztupels:Extended;
var counter:longint;
begin;
if aktspalte<>-1 then begin
//Berechne Tupels welche gespeichert werden
try
storetupels:=0;
for counter:=0 to anzd-1 do begin
storetupels:=storetupels+countdaten[counter,APA[aktspalte,aktzeile].hierstufe[coun
ter]];
end;
Result:=storetupels;
except
Result:=0;
- 314 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end;
end else //BFT
begin;
//Berechne die Tupels welche abgefragt werden
anztupels:=0;
for counter:=0 to anzd-1 do begin;
anztupels:=anztupels+countdaten[counter,0];
end;
Result:=anztupels;
end;
end;
function TAPA_Grid.deltaBftW(aktspalte,aktzeile:longint;Query:boolean):Extended;
var anztupels,storetupels:Extended; //Zähler
var SummeBerechnungendeltaBFTW:Extended;
begin;
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//Berechne die Kosten für das Erzeugen des Würfels aus dem BFT table
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
anztupels:=gettupel(-1,-1);
storetupels:=gettupel(aktspalte,aktzeile);
try
if Query= true then begin
SummeBerechnungendeltaBFTW:=
(
(
(
((strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(anztupels+(2*storetupels))))
)
/
strtofloat(APA_Parameter.APA_Thomas_timemax.text)
)+
(
(storetupels*
log2(storetupels)*strtofloat(APA_Parameter.APA_Thomas_timecpu.Text))
/
strtofloat(APA_Parameter.APA_Thomas_timemax.text)
)
)
* (APA_Parameter.APA_Thomas_Importance.Position/100);
end else begin
SummeBerechnungendeltaBFTW:=
(
((
((strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(anztupels+(2*storetupels))))
+
(strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*storetupels)
)
/
strtofloat(APA_Parameter.APA_Thomas_timemax.text)
)+
(
(storetupels*
log2(storetupels)*strtofloat(APA_Parameter.APA_Thomas_timecpu.Text))
/
strtofloat(APA_Parameter.APA_Thomas_timemax.text)
- 315 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
)
)
* (APA_Parameter.APA_Thomas_Importance.Position/100);
SummeBerechnungendeltaBFTW:=SummeBerechnungendeltaBFTW
+
((
(strtofloat(APA_Parameter.APA_Thomas_timestore.text)*storetupels)
/
strtofloat(APA_Parameter.APA_Thomas_spacemax.text)
)
* (1-(APA_Parameter.APA_Thomas_Importance.Position/100))
);
end;
except
showmessage('Error in Parameters');
SummeBerechnungendeltaBFTW:=0;
end;
Result:=SummeBerechnungendeltaBFTW;
end;
function
TAPA_Grid.deltaVW(spalte,zeile,aktspalte,aktzeile:longint;query:boolean):Extended;
var anztupels, storetupels:Extended; //Zähler
var SummeBerechnungendeltaVW:Extended;
begin;
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//Berechne die Kosten für das Berechnen des Würfels aus dem BFT table
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
SummeBerechnungendeltaVW:=0;
if (spalte<>aktspalte)or(zeile<>aktzeile) then begin
if spalte<>-1 then begin
anztupels:=gettupel(spalte,zeile);
storetupels:=gettupel(aktspalte,aktzeile);
try
if Query=true then begin
//ABfrage
SummeBerechnungendeltaVW:=
(
((
((strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(anztupels+(2*storetupels))))
)
/
strtofloat(APA_Parameter.APA_Thomas_timemax.text)
)+
(
(storetupels*
log2(storetupels)*strtofloat(APA_Parameter.APA_Thomas_timecpu.Text))
/
strtofloat(APA_Parameter.APA_Thomas_timemax.text)
)
)
* (APA_Parameter.APA_Thomas_Importance.Position/100);
end else begin
//Materialisieren
SummeBerechnungendeltaVW:=
(
((
((strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(anztupels+(2*storetupels))))
+
(strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*storetupels)
- 316 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
)
/
strtofloat(APA_Parameter.APA_Thomas_timemax.text)
)+
(
(storetupels*
log2(storetupels)*strtofloat(APA_Parameter.APA_Thomas_timecpu.Text))
/
strtofloat(APA_Parameter.APA_Thomas_timemax.text)
)
)
* (APA_Parameter.APA_Thomas_Importance.Position/100);
SummeBerechnungendeltaVW:=SummeBerechnungendeltaVW
+
((
(strtofloat(APA_Parameter.APA_Thomas_timestore.text)*storetupels)
/
strtofloat(APA_Parameter.APA_Thomas_spacemax.text)
)
* (1-(APA_Parameter.APA_Thomas_Importance.Position/100))
);
end;
except
showmessage('Error in Parameters');
SummeBerechnungendeltaVW:=0;
end;
end //spalte -1
else begin
SummeBerechnungendeltaVW:=deltaBftW(aktspalte,aktzeile,Query);
end;
end;
Result:=SummeBerechnungendeltaVW;
end;
function
TAPA_Grid.GetMinDerivatOfSpalte(aktspalte,aktzeile:longint;Query:boolean):longint;
var counter:longint;
New:string;
derivat:longint;
mincost:Extended;
aus:boolean;
begin
try
derivat:=0;mincost:=0; aus:=false;
counter:=0;
repeat;
if counter<=Memorywuerfel.count-1 then begin
New:=Memorywuerfel[counter];
if
isderivat(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),aktspalte,aktzeile)
then begin;
if Userandomcosts1.Checked=false then begin
if (mincost=0)or
(deltaVW(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),aktspalte,aktzeile,Que
ry)<mincost)
then begin;
derivat:=strtoint(copy(new,1,30));
mincost:=deltaVW(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),aktspalte,aktz
eile,Query);
end;
end else begin;
//Kosten aus der Datei
if Query=false then begin
- 317 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if (mincost=0)or
(getbuild(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),aktspalte,aktzeile)<m
incost)
then begin;
derivat:=strtoint(copy(new,1,30));
mincost:=getbuild(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),aktspalte,akt
zeile);
end;
end else begin
if (mincost=0)or
(getquery(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),aktspalte,aktzeile)<m
incost)
then begin
derivat:=strtoint(copy(new,1,30));
mincost:=getquery(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),aktspalte,akt
zeile);
end;
end;
end;
end;
end;
counter:=counter+1;
if (counter>Memorywuerfel.Count-1) then begin;
aus:=true;
end else begin
if
(Memorywuerfel[counter]=auffuellen(inttostr(aktspalte),30)+auffuellen(inttostr(akt
zeile),30))and(Query=false) then
aus:=true;
end;
until (aus=true);
Result:=derivat;
except
Result:=0;
end;
end;
function
TAPA_Grid.GetMinDerivatOfZeile(aktspalte,aktzeile:longint;Query:boolean):longint;
var counter:longint;
New:string;
derivat:longint;
mincost:Extended;
aus:boolean;
begin
try
derivat:=0;mincost:=0; aus:=false;
counter:=0;
repeat;
if counter<=Memorywuerfel.count-1 then begin
New:=Memorywuerfel[counter];
if
isderivat(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),aktspalte,aktzeile)
then begin;
if Userandomcosts1.Checked=false then begin
if (mincost=0)or
(deltaVW(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),aktspalte,aktzeile,Que
ry)<mincost)
then begin;
derivat:=strtoint(copy(new,31,30));
mincost:=deltaVW(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),aktspalte,aktz
eile,Query);
end;
end else begin;
//Kosten aus der Datei
- 318 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if Query=false then begin
if (mincost=0)or
(getbuild(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),aktspalte,aktzeile)<m
incost)
then
begin;
derivat:=strtoint(copy(new,31,30));
mincost:=getbuild(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),aktspalte,akt
zeile);
end;
end else begin
if (mincost=0)or
(getquery(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),aktspalte,aktzeile)<m
incost)
then begin;
derivat:=strtoint(copy(new,31,30));
mincost:=getquery(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),aktspalte,akt
zeile);
end;
end;
end; // von if Userandomcosts1.Checked=true
end; //Ende von if
isderivat(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),aktspalte,aktzeile)
end; //Ende von if counter<=Memorywuerfel.count-1
counter:=counter+1;
if (counter>Memorywuerfel.Count-1) then begin;
aus:=true;
end else begin
if
(Memorywuerfel[counter]=auffuellen(inttostr(aktspalte),30)+auffuellen(inttostr(akt
zeile),30))and(Query=false) then
aus:=true;
end;
until (aus=true);
Result:=derivat;
except
Result:=0;
end;
end;
procedure TAPA_Grid.berechneProsser();
var spaceortime_limit_reached:boolean;
counter:longint;
aktzeile, aktspalte:longint;
spalte,zeile:longint; //gibt den aktuellen Cursor im Gitter an//
spacemax:Extended;
isderivatof,added:boolean;
timemax:Extended;
merkvalue:Extended;
BerechneE:Extended;
new:string;
begin
Button_remove_materialized_cubes.Click;//Entferne alle materialisierten Würfel aus dem
APA
Memorywuerfel:= TStringList.Create;
//Erzeuge die Liste der ausgewählten Würfel
Listbox1.Items.Clear;
try
{Starte HEURISTIK von Alexander PROSSER}
//Setze maximalen Speicherplatz und Zeit
spacemax:=strtofloat(APA_Parameter.APA_Thomas_spacemax.text);
timemax:=strtofloat(APA_Parameter.APA_Thomas_timemax.text);
- 319 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
spaceortime_limit_reached:=false;
//Bestimmen des ersten Cube Anfang
//********************************
//Schleife für alle Würfel, welche noch nicht ausgewählt wurden//
for zeile:=0 to anzzeilen-1 do begin;
for spalte:=0 to anzspalten-1 do begin;
//zeile und spalte symbolisieren einen Würfel
// v welcher zugestetz werden könnte
BerechneE:=0;
if (APA[spalte,zeile].farbe=clYellow) then
begin; //Wenn redundanzfrei dann beginne//
Listbox1.Items.Add('');listbox1.Items.Add('++++++++++++++++Kontrolliere
Zelle '+inttostr(spalte)+':'+inttostr(zeile));
//Setzte den Wert für E(m) auf 0
for aktzeile:=0 to anzzeilen-1 do begin
for aktspalte:=0 to anzspalten-1 do begin
//aktzeile und aktspalte symbolisieren den würfel w
//Feststellen ob der Würfel redundanzfrei und ausgewählt ist//
if
(APA[aktspalte,aktzeile].farbe=clYellow)and(APA[aktspalte,aktzeile].gewicht<>0)
then begin
//if //aktuelle Würfel ist ein Derivat von aktellem v
if
(isderivat(spalte,zeile,aktspalte,aktzeile)=true)and(APA[aktspalte,aktzeile].inter
essant=true) then begin
listbox1.Items.Add('Schau mir das an: ist Derivat und nicht
0 '+inttostr(aktspalte)+':'+inttostr(aktzeile));
//Berechne Summe aller Delta w
if Userandomcosts1.Checked=false then begin
BerechneE:=BerechneE+
((deltaBftW(aktspalte,aktzeile,false)deltaVW(spalte,zeile,aktspalte,aktzeile,false))*(APA[aktspalte,aktzeile].gewicht))
;
listbox1.Items.Add('Berechne'+floattostr(deltaBftW(aktspalte,aktzeile,false))+'-'
+floattostr(deltaVW(spalte,zeile,aktspalte,aktzeile,false))+'*'+floattostr((APA[ak
tspalte,aktzeile].gewicht)));
end else begin
BerechneE:=BerechneE+
((getbuild(-1,-1,aktspalte,aktzeile)getbuild(spalte,zeile,aktspalte,aktzeile))*(APA[aktspalte,aktzeile].gewicht));
listbox1.Items.Add('Berechne'+floattostr(getbuild(-1,1,aktspalte,aktzeile))+'-'
+floattostr(getbuild(spalte,zeile,aktspalte,aktzeile))+'*'+floattostr((APA[aktspal
te,aktzeile].gewicht)));
end;
end; //Wenn Derivat
end; //Wenn Würfel ist redundanzfrei
end;{Ende von aktspalte}
end;{Ende von aktzeile}
if Userandomcosts1.Checked=false then begin
listbox1.Items.add('Gesamtwert für BerechneE :'+floattostr(BerechneE));
APA[spalte,zeile].value:=(BerechneE-deltaBftW(spalte,zeile,false));
listbox1.Items.Add('Wert eintragen für Zelle
'+inttostr(spalte)+':'+inttostr(zeile)+': Wert:
'+floattostr(APA[spalte,zeile].value)+' Gewicht:
'+floattostr((APA[spalte,zeile].gewicht)));
- 320 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if APA[spalte,zeile].gewicht<>0 then
listbox1.Items.add('=================================================');
end else begin
listbox1.Items.add('Gesamtwert für BerechneE :'+floattostr(BerechneE));
APA[spalte,zeile].value:=(BerechneE-getbuild(-1,-1,spalte,zeile));
listbox1.Items.Add('Wert eintragen für Zelle
'+inttostr(spalte)+':'+inttostr(zeile)+': Wert:
'+floattostr(APA[spalte,zeile].value)+' Gewicht:
'+floattostr((APA[spalte,zeile].gewicht)));
if APA[spalte,zeile].gewicht<>0 then
listbox1.Items.add('=================================================');
end;
end{von Redundanzfrei}
else APA[spalte,zeile].value:=0;
end;{For Schleife spalte}
end;{For Schleife zeilen}
//Materialisiere als ersten Würfel jenen mit dem besten Value
//Finde den höchsten Wert
merkvalue:=APA[0,0].value;aktzeile:=0;aktspalte:=0;
for zeile:=0 to anzzeilen-1 do begin;
for spalte:=0 to anzspalten-1 do begin;
if
((APA[spalte,zeile].value>merkvalue)or((merkvalue=0)and(Minusnehmen1.Checked=true)
))
and (APA[spalte,zeile].value<>0) then begin
merkvalue:=APA[spalte,zeile].value;//Wert merken
aktspalte:=spalte;aktzeile:=zeile;//Merken der Spalte und Zeile
end;
end;
end;
if merkvalue=0 then spaceortime_limit_reached:=true;
if Userandomcosts1.Checked=false then begin
timemax:=timemax-(strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(gettupel(-1,1)+(2*gettupel(aktspalte,aktzeile)))+
+strtofloat(APA_Parameter.APA_Thomas_timecpu.text)*gettupel(aktspalte,aktzeile)*lo
g2(gettupel(aktspalte,aktzeile))+
strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*gettupel(aktspalte,aktzeile));
end else begin
timemax:=timemax-getbuild(-1,-1,aktspalte,aktzeile);
end;
spacemax:=spacemax(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(aktspalte,aktzei
le));
if (spacemax<0) or (timemax<0) then begin
showmessage('Limit erreicht');
spaceortime_limit_reached:=true;
end else begin
new:=auffuellen(inttostr(aktspalte),30);
new:=new+auffuellen(inttostr(aktzeile),30);
Memorywuerfel.Add(new);
APA[aktspalte,aktzeile].materalisieren:=true;
matcount:=matcount+1;
APA[aktspalte,aktzeile].matcount:=matcount;
end;
//Bestimmen des ersten Cube Ende
//*************************
//Festellen der Zusatzwürfeln
//***************************
- 321 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if ProssernurersterLauf1.Checked=false then begin
while (spaceortime_limit_reached=false) do begin;
//Schleife für alle Würfel, welche noch nicht ausgewählt wurden//
for zeile:=0 to anzzeilen-1 do begin;
for spalte:=0 to anzspalten-1 do begin;
//zeile und spalte symbolisieren einen Würfel
// v welcher zugestetz werden könnte
//Setzte den Wert für E(m) auf 0
BerechneE:=0;
//Alle Wuerfel Value auf 0 setzen
for aktzeile:=0 to anzzeilen-1 do begin;
for aktspalte:=0 to anzspalten-1 do begin;
APA[aktspalte,aktzeile].value:=0;
end;
end;
if (APA[spalte,zeile].farbe=clYellow) then
begin; //Wenn redundanzfrei dann beginne//
Listbox1.items.add('+++++++++++');
listbox1.Items.Add('Kontrolliere zweite Schleife Zelle
'+inttostr(spalte)+':'+inttostr(zeile)+': Wert:
'+floattostr(APA[spalte,zeile].value)+' Gewicht:
'+floattostr(APA[spalte,zeile].gewicht));
//Stelle fest, ob Würfel schon zugesetzt
added:=false;
for counter:=0 to Memorywuerfel.Count-1 do begin
New:=Memorywuerfel[counter];
if
(strtoint(copy(new,31,30))=zeile)and(strtoint(copy(new,1,30))=spalte) then
added:=true;
end;
if added=true then listbox1.items.add('++++ Würfel schon zugesetzt
++++');
if added=false then begin;
//Würfel ist noch nicht in der Menge der bereits ausgewählten Würfel//
isderivatof:=false;
for counter:=0 to Memorywuerfel.Count-1 do begin
New:=Memorywuerfel[counter];
if
isderivat(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),spalte,zeile) then
begin;
isderivatof:=true;
Listbox1.Items.Add(copy(new,1,30)+':'+copy(new,31,30)+' kann erzeugen
'+inttostr(spalte)+':'+inttostr(zeile))
end;
end;
if isderivatof=false then begin
//ist kein Derivat Begin ++++++++++++++++++++++++
//wird also aus dem BFT berechnet
//Berechne alle Zellen ein
for aktzeile:=0 to anzzeilen-1 do begin
for aktspalte:=0 to anzspalten-1 do begin
//aktzeile und aktspalte symbolisieren den würfel w
//Feststellen ob der Würfel redundanzfrei ist//
if
(APA[aktspalte,aktzeile].farbe=clYellow)and(APA[aktspalte,aktzeile].gewicht<>0)
then begin
//if //aktuelle Würfel ist ein Derivat von aktellem v
- 322 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if isderivat(spalte,zeile,aktspalte,aktzeile)=true then
begin
listbox1.Items.add('Kontrolliere Würfel
'+inttostr(aktspalte)+'.'+inttostr(aktzeile));
//Wenn u aus einem bereits materialisierten Würfel
abgebildet werden kann
isderivatof:=false;
for counter:=0 to Memorywuerfel.Count-1 do begin
New:=Memorywuerfel[counter];
if
isderivat(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),spalte,zeile) then
begin;
Listbox1.Items.Add(copy(new,1,30)+':'+copy(new,31,30)+' ist auch ein derivat von
'+inttostr(spalte)+':'+inttostr(zeile));
isderivatof:=true;
end;
end;
if isderivatof=false then begin;
if Userandomcosts1.Checked=false then begin
BerechneE:=BerechneE+((deltaBftW(aktspalte,aktzeile,false)deltaVW(spalte,zeile,aktspalte,aktzeile,false))*(APA[aktspalte,aktzeile].gewicht))
;
listbox1.Items.Add('Berechne'+floattostr(deltaBftW(aktspalte,aktzeile,false))+'-'
+floattostr(deltaVW(spalte,zeile,aktspalte,aktzeile,false))+'*'+floattostr((APA[ak
tspalte,aktzeile].gewicht)));
end//von Userkostenrandom
else
begin
BerechneE:=BerechneE+((getbuild(-1,1,aktspalte,aktzeile)getbuild(spalte,zeile,aktspalte,aktzeile))*(APA[aktspalte,aktzeile].gewicht));
listbox1.Items.Add('Berechne'+floattostr(getbuild(1,-1,aktspalte,aktzeile))+'-'
+floattostr(getbuild(spalte,zeile,aktspalte,aktzeile))+'*'+floattostr((APA[aktspal
te,aktzeile].gewicht)));
end;
end else
begin
if Userandomcosts1.Checked=false then begin
BerechneE:=BerechneE+
max(0,((deltaVW(GetMinDerivatOfSpalte(aktspalte,aktzeile,false),
GetMinDerivatOfZeile(aktspalte,aktzeile,false),aktspalte,aktzeile,false)deltaVW(spalte,zeile,aktspalte,aktzeile,false))*(APA[aktspalte,aktzeile].gewicht))
);
listbox1.Items.Add('Berechne'+floattostr(deltaVW(GetMinDerivatOfSpalte(aktspalte,a
ktzeile,false),
GetMinDerivatOfZeile(aktspalte,aktzeile,false),aktspalte,aktzeile,false))+'-'
+floattostr(deltaVW(spalte,zeile,aktspalte,aktzeile,false))+'*'+floattostr((APA[ak
tspalte,aktzeile].gewicht)));
end//von Userkosten
else
begin
BerechneE:=BerechneE+
- 323 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
max(0,((getbuild(GetMinDerivatOfSpalte(aktspalte,aktzeile,false),
GetMinDerivatOfZeile(aktspalte,aktzeile,false),aktspalte,aktzeile)getbuild(spalte,zeile,aktspalte,aktzeile))*(APA[aktspalte,aktzeile].gewicht)));
listbox1.Items.Add('Berechne'+floattostr(getbuild(GetMinDerivatOfSpalte(aktspalte,
aktzeile,false),
GetMinDerivatOfZeile(aktspalte,aktzeile,false),aktspalte,aktzeile))+'-'
+floattostr(getbuild(spalte,zeile,aktspalte,aktzeile))+'*'+floattostr((APA[aktspal
te,aktzeile].gewicht)));
end;
end;
end; //Wenn Derivat
end; //Wenn Würfel ist redundanzfrei
end;//Ende von aktspalte
end;//Ende von aktzeile
if Userandomcosts1.Checked=false then begin
APA[spalte,zeile].value:=BerechneE-deltaBftW(spalte,zeile,false);
listbox1.Items.add('BerechneE für
'+inttostr(spalte)+':'+inttostr(Zeile)+' ist '+floattostr(BerechneEdeltaBftW(spalte,zeile,false)));
end//von Userkosten
else begin
APA[spalte,zeile].value:=BerechneE-getbuild(-1,-1,spalte,zeile);
listbox1.Items.add('BerechneE für
'+inttostr(spalte)+':'+inttostr(Zeile)+' ist '+floattostr(BerechneE-getbuild(-1,1,spalte,zeile)));
end;
end//von ist kein Derivat ++++++++++++++++++++++
else begin//von ist ein Derivat ++++++++++++++++++++++++
listbox1.Items.Add('is a derivat Cell
'+inttostr(spalte)+':'+inttostr(zeile));
for aktzeile:=0 to anzzeilen-1 do begin
for aktspalte:=0 to anzspalten-1 do begin
//aktzeile und aktspalte symbolisieren den würfel w
//Feststellen ob der Würfel redundanzfrei ist//
if (APA[aktspalte,aktzeile].farbe=clYellow)
and(APA[aktspalte,aktzeile].gewicht<>0) then begin
//if //aktuelle Würfel ist ein Derivat von aktellem v
if isderivat(spalte,zeile,aktspalte,aktzeile)=true then
begin
if Userandomcosts1.Checked=false then begin
BerechneE:=BerechneE+
max(0,((deltaVW(GetMinDerivatOfSpalte(aktspalte,aktzeile,false),
GetMinDerivatOfZeile(aktspalte,aktzeile,false),aktspalte,aktzeile,false)deltaVW(spalte,zeile,aktspalte,aktzeile,false))*(APA[aktspalte,aktzeile].gewicht))
);
listbox1.items.add('Min Parent is
'+inttostr(GetMinDerivatOfSpalte(aktspalte,aktzeile,false))+':'+
inttostr(GetMinDerivatOfZeile(aktspalte,aktzeile,false)));
listbox1.Items.Add('Berechne 0 oder
'+floattostr(deltaVW(GetMinDerivatOfSpalte(aktspalte,aktzeile,false),
GetMinDerivatOfZeile(aktspalte,aktzeile,false),aktspalte,aktzeile,false))+'-'
- 324 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
+floattostr(deltaVW(spalte,zeile,aktspalte,aktzeile,false))+'*'+floattostr((APA[ak
tspalte,aktzeile].gewicht)));
end//of Userkosten
else begin
BerechneE:=BerechneE+
max(0,((getbuild(GetMinDerivatOfSpalte(aktspalte,aktzeile,false),
GetMinDerivatOfZeile(aktspalte,aktzeile,false),aktspalte,aktzeile)getbuild(spalte,zeile,aktspalte,aktzeile))*(APA[aktspalte,aktzeile].gewicht)));
listbox1.items.add('Min Parent is
'+inttostr(GetMinDerivatOfSpalte(aktspalte,aktzeile,false))+':'+
inttostr(GetMinDerivatOfZeile(aktspalte,aktzeile,false)));
listbox1.Items.Add('Berechne 0 oder
'+floattostr(getbuild(GetMinDerivatOfSpalte(aktspalte,aktzeile,false),
GetMinDerivatOfZeile(aktspalte,aktzeile,false),aktspalte,aktzeile))+'-'
+floattostr(getbuild(spalte,zeile,aktspalte,aktzeile))+'*'+floattostr((APA[aktspal
te,aktzeile].gewicht)));
end;
end; //Wenn Derivat
end; //Wenn Würfel ist redundanzfrei
end;//Ende von aktspalte
end;//Ende von aktzeile
if Userandomcosts1.Checked=false then begin
APA[spalte,zeile].value:=BerechneEdeltaVW(GetMinDerivatOfSpalte(spalte,zeile,false),GetMinDerivatOfZeile(spalte,zeil
e,false),spalte,zeile,false);
listbox1.Items.add('BerechneE für
'+inttostr(spalte)+':'+inttostr(Zeile)+' ist
'+floattostr(APA[spalte,zeile].value));
end//Userkosten
else begin
APA[spalte,zeile].value:=BerechneEgetbuild(GetMinDerivatOfSpalte(spalte,zeile,false),GetMinDerivatOfZeile(spalte,zei
le,false),spalte,zeile);
listbox1.Items.add('BerechneE für
'+inttostr(spalte)+':'+inttostr(Zeile)+' ist
'+floattostr(APA[spalte,zeile].value));
end;
end;//von ist ein Derivat ++++++++++++++++++++++++++++
end; //Würfel ist noch nicht in der Liste ENDE
end;//von Redundanzfrei
end;//For Schleife spalte
end;//For Schleife zeilen
//Materialisiere als nächsten Würfel jenen mit dem besten Value
//Finde den höchsten Wert
merkvalue:=0;aktzeile:=0;aktspalte:=0;isderivatof:=false;
for zeile:=0 to anzzeilen-1 do begin;
for spalte:=0 to anzspalten-1 do begin;
if
((APA[spalte,zeile].value>merkvalue)or((merkvalue=0)and(Minusnehmen1.Checked=true)
))
and (APA[spalte,zeile].value<>0) then begin
merkvalue:=APA[spalte,zeile].value;//Wert merken
- 325 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
aktspalte:=spalte;aktzeile:=zeile;//Merken der Spalte und Zeile
//Festellen, ob aus dem BFT materialisiert wird oder aus einem bereits
//materialisierten Würfel
for counter:=0 to Memorywuerfel.Count-1 do begin
New:=Memorywuerfel[counter];
if
isderivat(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),spalte,zeile) then
begin;
isderivatof:=true;
end;
end;
end;
end;
end;
if merkvalue=0 then begin;
spaceortime_limit_reached:=true; //Wenn kein Würfel einen Wert hat beenden
showmessage('Alle Würfel 0');
end
else
begin;
if isderivatof=false then begin
//Wird aus dem BFT erzeugt
if Userandomcosts1.Checked=false then begin
timemax:=timemax(strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(gettupel(-1,1)+(2*gettupel(aktspalte,aktzeile)))+
+strtofloat(APA_Parameter.APA_Thomas_timecpu.text)*gettupel(aktspalte,aktzeile)*lo
g2(gettupel(aktspalte,aktzeile))+
strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*gettupel(aktspalte,aktzeile));
end else begin
timemax:=timemax-getbuild(-1,-1,aktspalte,aktzeile);
end;
spacemax:=spacemax(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(aktspalte,aktzei
le));
end else begin
//Wird aus bereits materialisiertem Würfel erzeugt
if Userandomcosts1.Checked=false then begin
timemax:=timemax-(strtofloat(APA_Parameter.APA_Thomas_timeio.text)*
(gettupel(GetMinDerivatOfSpalte(aktspalte,aktzeile,false),GetMinDerivatOfZeile(akt
spalte,aktzeile,false))+(2*gettupel(aktspalte,aktzeile)))+
+strtofloat(APA_Parameter.APA_Thomas_timecpu.text)*gettupel(aktspalte,aktzeile)*lo
g2(gettupel(aktspalte,aktzeile))+
strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*gettupel(aktspalte,aktzeile));
end else begin
timemax:=timemaxgetbuild(GetMinDerivatOfSpalte(aktspalte,aktzeile,false),GetMinDerivatOfZeile(akts
palte,aktzeile,false),
aktspalte,aktzeile);
end;
spacemax:=spacemax(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(aktspalte,aktzei
le));
end;
end;
- 326 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if timemax<0 then showmessage('timemax erreicht');
if spacemax<0 then showmessage('spacemax erreicht');
if (spacemax<0) or (timemax<0) then begin
spaceortime_limit_reached:=true;
end else begin
new:=auffuellen(inttostr(aktspalte),30);
new:=new+auffuellen(inttostr(aktzeile),30);
Memorywuerfel.Add(new);
APA[aktspalte,aktzeile].materalisieren:=true;
matcount:=matcount+1;
APA[aktspalte,aktzeile].matcount:=matcount;
end;
end; {(spaceortime_limit_reached=false)}
end; // of ProssernurersterLauf1.checked
{Starte HEURISTIK von Alexander PROSSER ENDE}
finally
Memorywuerfel.Free;
end;
materialzeichnen;
APAGrid.Repaint;
showmessage('Ready');
end;
procedure TAPA_Grid.Button1Click(Sender: TObject);
begin;
mustsave:=true;
berechneProsser();
end;
procedure TAPA_Grid.Item1Click(Sender: TObject);
begin
mustsave:=true;
APA[zellespalte,zellezeile].interessant:=true;
APA[zellespalte,zellezeile].gewicht:=strtoint(APA_Parameter.APA_Degreecounts.Items[(Send
er as TMenuItem).Tag]);
APA[zellespalte,zellezeile].gewichtlevel:=(Sender as TMenuItem).Tag;
APAGrid.Repaint;
end;
procedure TAPA_Grid.Button2Click(Sender: TObject);
var PossibleCubes, SecondCubes:TStringList;
var NewStringList:TStringList;
var MatCubes, SecondMatCubes: TStringList;
var MerkMatCubes, MerkMatCubesfertig:TList;
var MyReqCubes, MyMatCubes:TStringList;
var zeile,spalte, merkpos:longint;
var merkcosts,merkcosts2:Extended;
var Sets:array of Extended;
var Setcounter, NewSetsforEachIteration, Setcount, maxSets:longint;
var zahler,zahler2, zahler3, counter, zahlersecond1, zahlersecond2,
merkepossecond:longint;
var derivzeile,derivspalte,aktzeile,aktspalte:longint;
var spaceortimelimitreached,nocubefound,bereitsmaterialisiert:boolean;
var kannabgeleitetwerden:boolean;
var timemax,spacemax, alttimemax,altspacemax,Summederiv, MinMatCosts,
MinQueryCosts:Extended;
var parentzeile,parentspalte, merkspalte,merkzeile:longint;
var kannderivatabgeleitetwerden:boolean;
var parentderivatzeile,parentderivatspalte:longint;
var merkspaltesecond,merkzeilesecond:longint;
var faktor:real;
var count_of_derivates:longint;
var foundbestcube:boolean;
var maxvalue:Extended;
var countofpaths:longint;
- 327 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
var merksecondcosts:Extended;
begin
Button_remove_materialized_cubes.Click;
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');
{$i-}
reset(fKosten);
{$i+}
if ioresult<>0 then begin; showmessage('cost database error ');exit;end;
try
APA_Grid.Enabled:=false;
if (APA_Options.APA_ShowScreenheuristic.Checked) then begin
APA_Show_Process.Show;
APA_Show_Process.APA_Protocoll.Clear;
end;
listbox1.Items.Clear;
{*********************************************************}
{1. Vorbereitungen für die Iteration}
{*********************************************************}
APA_Show_Process.ausgabe('Start Thomas Achs heuristic ...');
{1.a Erzeuge die Liste der materialisierungswürdigen Würfel}
PossibleCubes:=TStringList.Create();
SecondCubes:=TStringList.Create();
MerkMatCubes:=TList.Create();
MerkMatCubesfertig:=TList.Create();
MatCubes:=TStringList.Create();
SecondMatCubes:=TStringList.Create();
try
APA_Show_Process.ausgabe('Search for required cubes...');
counter:=0;
for aktzeile:=0 to anzzeilen-1 do begin
for aktspalte:=0 to anzspalten-1 do begin
if (APA[aktspalte,aktzeile].interessant=true)and
(APA[aktspalte,aktzeile].farbe=clYellow) then begin//Auswählen des Würfels
listbox1.Items.Add('Required Cube:
'+auffuellen(inttostr(aktspalte),10)+auffuellen(inttostr(aktzeile),10));
PossibleCubes.Add(auffuellen(inttostr(aktspalte),10)+auffuellen(inttostr(aktzeile)
,10));
counter:=counter+1;
end;//of Auswählen des Würfels
end;//of aktspalte
end;//of aktzeile
APA_Show_Process.ausgabe('
Found '+inttostr(counter)+' required Cubes');
{1.b Setze Derivate zu}
if tomohnederivate1.Checked=false then begin
APA_Show_Process.ausgabe('Search for parent cubes or required cubes...');
counter:=0;
for aktzeile:=0 to anzzeilen-1 do begin
for aktspalte:=0 to anzspalten-1 do begin
if
(APA[aktspalte,aktzeile].farbe=clYellow)and(APA[aktspalte,aktzeile].interessant=fa
lse) then begin
count_of_derivates:=0;
for derivspalte:=0 to anzspalten-1 do begin;
for derivzeile:=0 to anzzeilen-1 do begin;
if (APA[derivspalte,derivzeile].interessant=true)and
(APA[derivspalte,derivzeile].farbe=clYellow) then begin
if isderivat(aktspalte,aktzeile,derivspalte,derivzeile) then begin
//Jetzt kontrollieren wir, ob dieser Würfel auch noch ein Derivat eines
anderen Würfels
count_of_derivates:=count_of_derivates+1;
end;//Ende von derivat
end;//Ende von interessant
- 328 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end;//of derivzeile
end;//of derivsspalte
if count_of_derivates>=1 then begin
listbox1.Items.Add('Derivat Cube:
'+auffuellen(inttostr(aktspalte),10)+auffuellen(inttostr(aktzeile),10));
PossibleCubes.Add(auffuellen(inttostr(aktspalte),10)+auffuellen(inttostr(aktzeile)
,10));
counter:=counter+1;
end;
end;//von Yellow
end;//aktspalte
end;//aktzeile
APA_Show_Process.ausgabe('Found '+inttostr(counter)+' parent cubes of required
cubes...');
end;//of tomohnederivate1
Setcount:=1;
NewSetsforEachIteration:=strtoint(trim(APA_Parameter.APA_Thomas_newsetsoneachiteration.t
ext));
maxSets:=strtoint(trim(APA_Parameter.APA_Thomas_countofsets.text));
setlength(Sets,MaxSets);
APA_Show_Process.ausgabe('Set of possible cubes of '+inttostr(counter)+' cubes is parent
cubes union required cubes');
{1.c. Setze limits}
spaceortimelimitreached:=false;
timemax:=strtofloat(APA_Parameter.APA_Thomas_timemax.Text);
spacemax:=strtofloat(APA_Parameter.APA_Thomas_spacemax.Text);
{*********************************************************}
{Ende 1. Vorbereitungen für die Iteration}
{*********************************************************}
{*********************************************************}
{2. Iterationen der Sets}
{*********************************************************}
Setcounter:=-1;
repeat;
{*********************************************************}
{2.1 Vorbereiten des Startsets für die Iteration}
{*********************************************************}
APA_Show_Process.ausgabe('Generate '+inttostr(Setcounter+2)+' Set');
APA_Show_Process.ausgabe('Add the best cube to the set as long as no limit reached ');
if (Setcounter<=MerkMatCubes.Count-1)or(Setcounter=-1) then begin
if Setcounter<>-1 then begin
//Laden der MatCubes
MatCubes.Clear;
NewStringList:=MerkMatCubes.items[Setcounter];
MatCubes.addstrings(NewStringList);
timemax:=strtofloat(APA_Parameter.APA_Thomas_timemax.Text);
spacemax:=strtofloat(APA_Parameter.APA_Thomas_spacemax.Text);
//Berechne Timelimits
for zahler:=0 to MatCubes.Count-1 do begin
aktspalte:=strtoint(copy(MatCubes[zahler],1,10));
aktzeile:=strtoint(copy(MatCubes[zahler],11,10));
//Feststellen aus wem der Würfel abgeleitet wird
//? gibt es ein x?
if (Userandomcosts1.Checked=false) then
MinMatCosts:=deltaBftW(aktspalte,aktzeile,false) else
MinMatCosts:=getbuild(-1,-1,aktspalte,aktzeile);
parentzeile:=-1;parentspalte:=-1;
- 329 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
for zahler2:=0 to zahler do begin
if
(isderivat(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],
11,10)),
aktspalte,aktzeile)=true)and(zahler<>zahler2) then
begin;
if (Userandomcosts1.Checked=false) then begin
if (MinMatCosts>
deltaVW(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],11,
10)),
aktspalte,aktzeile,false))
then
begin;
parentzeile:=strtoint(copy(MatCubes[zahler2],11,10));
parentspalte:=strtoint(copy(MatCubes[zahler2],1,10));
end;
end//of keine Zufallskosten
else
begin//Wenn Zufallskosten
if (MinMatCosts>
getbuild(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],11
,10)),
aktspalte,aktzeile))
then
begin;
parentzeile:=strtoint(copy(MatCubes[zahler2],11,10));
parentspalte:=strtoint(copy(MatCubes[zahler2],1,10));
end;
end;//Ende Wenn Zufallskosten
end;
end;
//Ende Feststellen des Würfels, welcher Materialisert werden soll und woher
if (Userandomcosts1.Checked=false) then begin
timemax:=timemax(strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(gettupel(-1,1)+(2*gettupel(aktspalte,aktzeile)))+
+strtofloat(APA_Parameter.APA_Thomas_timecpu.text)*gettupel(aktspalte,aktzeile)*lo
g2(gettupel(aktspalte,aktzeile))+
strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*gettupel(aktspalte,aktzeile));
spacemax:=spacemax(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(aktspalte,aktzei
le));
end else begin
timemax:=timemax-getbuild(parentspalte,parentzeile,aktspalte,aktzeile);;
spacemax:=spacemax(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(aktspalte,aktzei
le));
end;
end;
end;
{*********************************************************}
- 330 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
{Ende 2.1 Vorbereiten des Startsets für die Iteration}
{*********************************************************}
{*********************************************************}
{2.2. Beginn der Iteration des aktuellen Sets}
{*********************************************************}
spaceortimelimitreached:=false;
while(spaceortimelimitreached=false)and(stop=false) do begin
for zahler:=0 to PossibleCubes.Count-1 do begin
aktspalte:=strtoint(copy(PossibleCubes[zahler],1,10));
aktzeile:=strtoint(copy(PossibleCubes[zahler],11,10));
SecondCubes.Clear;
//Feststellen des Würfels, welcher Materialisert werden soll und woher
bereitsmaterialisiert:=false;
for zahler2:=0 to MatCubes.Count-1 do begin
if PossibleCubes[zahler]=MatCubes[zahler2] then begin;
bereitsmaterialisiert:=true;
end;
end;
if bereitsmaterialisiert=false then begin
//? gibt es ein x?
kannabgeleitetwerden:=false;
if (Userandomcosts1.Checked=false) then
MinMatCosts:=deltaBftW(aktspalte,aktzeile,false) else
MinMatCosts:=getbuild(-1,-1,aktspalte,aktzeile);
parentzeile:=-1;parentspalte:=-1;
{*********************************************************}
{2.2.1. Feststellen des Cubes aus dem der Cube c (zahler) materialisiert wird:
Dazu kontrolliere alle bereits materialisierten Cubes z (zahler2),
ob c aus z abgeleitet werden kann}
{*********************************************************}
for zahler2:=0 to MatCubes.Count-1 do begin
if
isderivat(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],1
1,10)),
aktspalte,aktzeile)=true then
begin;
if (Userandomcosts1.Checked=false) then begin
if (MinMatCosts>
deltaVW(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],11,
10)),
aktspalte,aktzeile,false))
then
begin;
kannabgeleitetwerden:=true;
parentzeile:=strtoint(copy(MatCubes[zahler2],11,10));
parentspalte:=strtoint(copy(MatCubes[zahler2],1,10));
MinMatCosts:=deltaVW(parentspalte,parentzeile,aktspalte,aktzeile,false);
end;
end//of keine Zufallskosten
else
begin//Wenn Zufallskosten
if (MinMatCosts>
getbuild(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],11
,10)),
aktspalte,aktzeile))
then
begin;
kannabgeleitetwerden:=true;
parentzeile:=strtoint(copy(MatCubes[zahler2],11,10));
- 331 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
parentspalte:=strtoint(copy(MatCubes[zahler2],1,10));
MinMatCosts:=getbuild(parentspalte,parentzeile,aktspalte,aktzeile);
end;
end;//Ende Wenn Zufallskosten
end;//isderivat
end;//for zahler2
//Ende Feststellen des Würfels, welcher Materialisert werden soll und woher
{*********************************************************}
{Ende 2.2.1. Feststellen des Cubes aus dem der Cube c (zahler) materialisiert wird:
Dazu kontrolliere alle bereits materialisierten Cubes z (zahler2),
ob c aus z abgeleitet werden kann}
{*********************************************************}
{*********************************************************}
{2.2.2. Festellen der Derivate und der Abfragekosten
der Summe der Derivate für den Cube c}
{*********************************************************}
Summederiv:=0;//Summe der Werte der Derivate
for zahler3:=0 to PossibleCubes.Count-1 do begin
derivspalte:=strtoint(copy(PossibleCubes[zahler3],1,10));
derivzeile:=strtoint(copy(PossibleCubes[zahler3],11,10));
faktor:=APA[derivspalte,derivzeile].gewicht;
if APA[derivspalte,derivzeile].interessant=true then begin
if isderivat(aktspalte,aktzeile,derivspalte,derivzeile)=true then
//dies ist der Würfel u
begin;
//? kann derivat abgeleitet werden?
kannderivatabgeleitetwerden:=false;
if (Userandomcosts1.Checked=false) then begin
if parentspalte<>-1 then
MinQueryCosts:=deltaVW(parentspalte,parentzeile,aktspalte,aktzeile,false)
else
MinQueryCosts:=deltaBftW(aktspalte,aktzeile,false);
end else
MinQueryCosts:=getbuild(parentspalte,parentzeile,aktspalte,aktzeile);
parentderivatspalte:=parentspalte;parentderivatzeile:=parentzeile;
for zahler2:=0 to MatCubes.Count-1 do begin
if
isderivat(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],1
1,10)),
derivspalte,derivzeile)=true then
begin;
if (Userandomcosts1.Checked=false) then begin
if (MinQueryCosts>
deltaVW(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],11,
10)),
derivspalte,derivzeile,true))
then
begin;
kannderivatabgeleitetwerden:=true;
parentderivatzeile:=strtoint(copy(MatCubes[zahler2],11,10));
parentderivatspalte:=strtoint(copy(MatCubes[zahler2],1,10));
MinQueryCosts:=deltaVW(parentderivatspalte,parentderivatzeile,derivspalte,derivzei
le,true);
end;
end//of keine Zufallskosten
else
begin//Wenn Zufallskosten
- 332 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if (MinQueryCosts>
getquery(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],11
,10)),
derivspalte,derivzeile))
then
begin;
kannderivatabgeleitetwerden:=true;
parentderivatzeile:=strtoint(copy(MatCubes[zahler2],11,10));
parentderivatspalte:=strtoint(copy(MatCubes[zahler2],1,10));
MinQueryCosts:=getquery(parentderivatspalte,parentderivatzeile,derivspalte,derivze
ile);
end;
end;//Ende Wenn Zufallskosten
end;
end;
{*********************************************************}
{2.2.2.1. Berechnen der Verbesserung der Abfragekosten
durch das Materialisieren von c}
{*********************************************************}
if kannabgeleitetwerden=false then begin
if kannderivatabgeleitetwerden=false then begin
if (Userandomcosts1.Checked=false) then begin
Summederiv:=Summederiv+
max(0,(deltaBFTw(derivspalte,derivzeile,true)Deltavw(aktspalte,aktzeile,derivspalte,derivzeile,true)))
*faktor;
end else begin
Summederiv:=Summederiv+
max(0,(getquery(-1,-1,derivspalte,derivzeile)getquery(aktspalte,aktzeile,derivspalte,derivzeile)))
*faktor;
end;
end else begin
if (Userandomcosts1.Checked=false) then begin
Summederiv:=Summederiv+max(0,
(deltaVW(parentderivatspalte,parentderivatzeile,derivspalte,derivzeile,true)Deltavw(aktspalte,aktzeile,derivspalte,derivzeile,true))
*faktor);
end else begin
Summederiv:=Summederiv+max(0,
(getquery(parentderivatspalte,parentderivatzeile,derivspalte,derivzeile)getquery(aktspalte,aktzeile,derivspalte,derivzeile))
*faktor);
end;
end;
end else begin
//kannabgeleitet werden =true
if (Userandomcosts1.Checked=false) then begin
Summederiv:=Summederiv+max(0,
(deltaVW(parentderivatspalte,parentderivatzeile,derivspalte,derivzeile,true)Deltavw(aktspalte,aktzeile,derivspalte,derivzeile,true))
*faktor);
end else
begin
Summederiv:=Summederiv+max(0,
(getquery(parentderivatspalte,parentderivatzeile,derivspalte,derivzeile)-
- 333 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
getquery(aktspalte,aktzeile,derivspalte,derivzeile))
*faktor);
end;
end;
{*********************************************************}
{Ende 2.2.2.1. Berechnen der Verbesserung der Abfragekosten
durch das Materialisieren von c}
{*********************************************************}
end;//of isderivat
end;//of ist interessant
end;//of zahler3
{*********************************************************}
{Ende 2.2.2. Festellen der Derivate und der Abfragekosten
der Summe der Derivate für den Cube c}
{*********************************************************}
{*********************************************************}
{2.2.3. Berechnen der Verbesserung der
Gesamtkosten durch das Materialisieren von c}
{*********************************************************}
if kannabgeleitetwerden=false then begin
if (Userandomcosts1.Checked=false) then begin
//Eintragen des Wertes
APA[aktspalte,aktzeile].value:=SummederivDeltaBftw(aktspalte,aktzeile,false);
APA[aktspalte,aktzeile].value2:=DeltaBftw(aktspalte,aktzeile,false);
end else
begin
//Eintragen des Wertes
APA[aktspalte,aktzeile].value:=Summederiv-getbuild(-1,1,aktspalte,aktzeile);
APA[aktspalte,aktzeile].value2:=getbuild(-1,-1,aktspalte,aktzeile);
end;
end else begin
if (Userandomcosts1.Checked=false) then begin
APA[aktspalte,aktzeile].value:=SummederivDeltaVW(parentspalte,parentzeile,aktspalte,aktzeile,false);
APA[aktspalte,aktzeile].value2:=DeltaVW(parentspalte,parentzeile,aktspalte,aktzeil
e,false);
end else
begin
APA[aktspalte,aktzeile].value:=Summederivgetbuild(parentspalte,parentzeile,aktspalte,aktzeile);
APA[aktspalte,aktzeile].value2:=getbuild(parentspalte,parentzeile,aktspalte,aktzei
le);
end;
end;
end;//of bereitsmateralisiert
{*********************************************************}
{Ende 2.2.3. Berechnen der Verbesserung der
Gesamtkosten durch das Materialisieren von c}
{*********************************************************}
end;//of zahler
{*********************************************************}
{2.2.4 Gibt es einen Cube c mit Positivem dK(c) (Kostenersparnis)
und innerhalb der Limits: True- dann setze den c mit Max(dK(c))
dem aktuellen Set zu; False - dann schließe das Set ab}
{*********************************************************}
maxvalue:=0;
nocubefound:=true;
for zahler:=0 to PossibleCubes.Count-1 do begin
listbox1.items.Add('Würfel '+PossibleCubes[zahler]);
- 334 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
listbox1.items.add(floattostr(APA[strtoint(copy(PossibleCubes[zahler],1,10)),strto
int(copy(PossibleCubes[zahler],11,10))].value));
{if APA[strtoint(copy(PossibleCubes[zahler],1,10)),
strtoint(copy(PossibleCubes[zahler],11,10))].value>maxvalue then begin}
aktspalte:=strtoint(copy(PossibleCubes[zahler],1,10));
aktzeile:=strtoint(copy(PossibleCubes[zahler],11,10));
Application.ProcessMessages;
//Feststellen, ob bereits materialisiert
bereitsmaterialisiert:=false;
for zahler2:=0 to MatCubes.Count-1 do begin
if PossibleCubes[zahler]=MatCubes[zahler2] then begin;
bereitsmaterialisiert:=true;
listbox1.Items.Add('Schon materalisiert');
end;
end;
//Feststellen, ob in Limits überschritten
alttimemax:=timemax;altspacemax:=spacemax;
listbox1.items.Add('Try Cube
'+auffuellen(inttostr(aktspalte),10)+auffuellen(inttostr(aktzeile),10));
listbox1.items.add('Value: '+floattostr(APA[aktspalte,aktzeile].value));
if (Userandomcosts1.Checked=false) then begin
timemax:=timemax(strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(gettupel(-1,1)+(2*gettupel(aktspalte,aktzeile)))+
+strtofloat(APA_Parameter.APA_Thomas_timecpu.text)*gettupel(aktspalte,aktzeile)*lo
g2(gettupel(aktspalte,aktzeile))+
strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*gettupel(aktspalte,aktzeile));
spacemax:=spacemax(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(aktspalte,aktzei
le));
end else begin
timemax:=timemax-APA[aktspalte,aktzeile].value2;
spacemax:=spacemax(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(aktspalte,aktzei
le));
end;
listbox1.items.add('timemax('+floattostr(timemax)+')');
listbox1.items.add('spacemax('+floattostr(spacemax)+')');
if (timemax<0)or(spacemax<0) then begin
bereitsmaterialisiert:=true;//Stelle auf bereitsmaterialisert
end;
timemax:=alttimemax;spacemax:=altspacemax;//Stelle Limits wieder zurück
if
(bereitsmaterialisiert=false)and(APA[strtoint(copy(PossibleCubes[zahler],1,10)),
strtoint(copy(PossibleCubes[zahler],11,10))].value>0) then begin
//Erzeuge Liste der Würfel,welche in die Limits passen
SecondCubes.add(PossibleCubes[zahler]);
end;
if (bereitsmaterialisiert=false) then begin;
if (APA[strtoint(copy(PossibleCubes[zahler],1,10)),
strtoint(copy(PossibleCubes[zahler],11,10))].value>maxvalue)
and(APA[strtoint(copy(PossibleCubes[zahler],1,10)),
strtoint(copy(PossibleCubes[zahler],11,10))].value>0) then begin
maxvalue:=APA[strtoint(copy(PossibleCubes[zahler],1,10)),
- 335 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
strtoint(copy(PossibleCubes[zahler],11,10))].value;
merkspalte:=strtoint(copy(PossibleCubes[zahler],1,10));//Merken der Spalte des
neuen Cubes
merkzeile:=strtoint(copy(PossibleCubes[zahler],11,10));//Merken der Zeile des
neuen Cubes
nocubefound:=false;
listbox1.Items.Add('Maxvalue:'+floattostr(maxvalue));
end;
end;
{end;}
end;//of zahler
if nocubefound=false then begin
listbox1.items.Add('Materialize Cube
'+auffuellen(inttostr(merkspalte),10)+auffuellen(inttostr(merkzeile),10));
listbox1.items.add('Value: '+floattostr(APA[merkspalte,merkzeile].value));
listbox1.items.add('================');
//Materialisiere den besten Cube
MatCubes.Add(auffuellen(inttostr(merkspalte),10)+auffuellen(inttostr(merkzeile),10
));
foundbestcube:=true;
//Timemax und spacemax berechnen
if (Userandomcosts1.Checked=false) then begin
timemax:=timemax(strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(gettupel(-1,1)+(2*gettupel(merkspalte,merkzeile)))+
+strtofloat(APA_Parameter.APA_Thomas_timecpu.text)*gettupel(merkspalte,merkzeile)*
log2(gettupel(merkspalte,merkzeile))+
strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*gettupel(merkspalte,merkzeile)
);
spacemax:=spacemax(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(merkspalte,merkz
eile));
end else begin
timemax:=timemax-APA[merkspalte,merkzeile].value2;
spacemax:=spacemax(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(merkspalte,merkz
eile));
end;
//Entferne aktuell besten Würfel aus der Liste Secondcubes
zahlersecond2:=0;
repeat;
if SecondCubes.count>0 then begin
if
(SecondCubes[zahlersecond2]=auffuellen(inttostr(merkspalte),10)+auffuellen(inttost
r(merkzeile),10))
then begin;
SecondCubes.Delete(zahlersecond2);
zahlersecond2:=SecondCubes.count;
end;
end;
zahlersecond2:=zahlersecond2+1;
until (zahlersecond2>SecondCubes.count-1);
{*********************************************************}
{2.2.4.1 Gibt es noch NewSetsForEachIteration Cubes,
welche das Limit erfüllen dann wähle die NewSetsForEachIteration
besten Cubes und eröffne neue Sets solange bis MaxSets erreicht.}
{*********************************************************}
//Erzeuge die neuen Wege, welche noch berechnet werden sollen
- 336 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
listbox1.items.Add('Try adding '+inttostr(NewSetsforEachIteration)+' new
Sets');
for zahlersecond2:=1 to NewSetsforEachIteration do begin
merksecondcosts:=0;
merkepossecond:=-1;
merkzeilesecond:=-1;merkspaltesecond:=-1;
for zahlersecond1:=0 to SecondCubes.count-1 do begin;
//Finde zweitbesten Cube
if (merkepossecond=1)or(merksecondcosts<APA[strtoint(copy(SecondCubes[zahlersecond1],1,10)),
strtoint(copy(SecondCubes[zahlersecond1],11,10))].value) then begin
merksecondcosts:=APA[strtoint(copy(SecondCubes[zahlersecond1],1,10)),
strtoint(copy(SecondCubes[zahlersecond1],11,10))].value;
merkspaltesecond:=strtoint(copy(SecondCubes[zahlersecond1],1,10));
merkzeilesecond:=strtoint(copy(SecondCubes[zahlersecond1],11,10));
merkepossecond:=zahlersecond1;
end;
end;//zahlersecond1
if (merksecondcosts>0) then begin
//Neuen Weg erzeugen
if (Setcount<maxSets) then begin
Setcount:=Setcount+1;
SecondMatCubes.Clear;
SecondMatCubes.AddStrings(MatCubes);
if (SecondMatCubes.Count>0) then begin
SecondMatCubes[SecondMatCubes.Count-1]:=
auffuellen(inttostr(merkspaltesecond),10)+auffuellen(inttostr(merkzeilesecond),10)
;
listbox1.items.Add('Found '+inttostr(zahlersecond2+1)+' best Cube:
'+SecondMatCubes[SecondMatCubes.Count-1]);
if merkepossecond<>-1 then SecondCubes.Delete(merkepossecond);
NewStringList:=TStringList.Create;
NewStringList.Clear;
NewStringList.AddStrings(SecondMatCubes);
MerkMatCubes.Add(NewStringList);
end//Ende if (SecondMatCubes.Count>0
else
listbox1.items.Add('Did not found '+inttostr(zahlersecond2+2)+' best
Cube');
end;//Ende if (Setcount<maxSets-1)
end;//Ende if (merksecondcosts>0)
end;//zahlersecond2
{*********************************************************}
{Ende 2.2.4.1 Gibt es noch NewSetsForEachIteration Cubes,
welche das Limit erfüllen dann wähle die NewSetsForEachIteration
besten Cubes und eröffne neue Sets solange bis MaxSets erreicht.}
{*********************************************************}
end else spaceortimelimitreached:=true;
{*********************************************************}
{Ende 2.2.4 Gibt es einen Cube c mit Positivem dK(c) (Kostenersparnis)
und innerhalb der Limits: True- dann setze den c mit Max(dK(c))
dem aktuellen Set zu; False - dann schließe das Set ab}
{*********************************************************}
end;//of spaceortimelimitreached
{*********************************************************}
{Ende 2.2. Beginn der Iteration des aktuellen Sets}
{*********************************************************}
{Speichere die MatCubes in der Liste}
if MatCubes.count>0 then begin
- 337 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
NewStringLIst:=TStringList.Create;
NewStringList.Clear;
NewStringList.AddStrings(MatCubes);
NewStringList:=getrightOrdertom(NewStringList);
MerkMatCubesfertig.Add(NewStringList);
APA_Show_Process.ausgabe(inttostr(Setcounter+2)+' Set found contain cubes ');
for counter:=0 to MatCubes.Count-1 do begin
APA_Show_Process.ausgabe('Cube No '+inttostr(counter)+'
('+inttostr(strtoint(copy(MatCubes[counter],1,10)))+':'+
inttostr(strtoint(copy(MatCubes[counter],11,10)))+')');
end;
end;
end;//of MerkMatCubes
Setcounter:=Setcounter+1;
until (Setcounter>=maxSets-1)or(Setcounter>Setcount)or(stop=true);//of wayszahler
{*********************************************************}
{Ende 2. Iteration der Sets}
{*********************************************************}
APA_Show_Process.ausgabe(inttostr(Setcounter+1)+' Sets are build ');
APA_Show_Process.ausgabe('Now select the set with lowest costs');
{*********************************************************}
{3. Berechne die Gesamtkosten für jedes Set}
{*********************************************************}
{Feststellen des besten Weges}
{*********************}
MyReqCubes:=TStringList.Create;
MyMatCubes:=TStringList.Create;
try
//Lege alle nicht redundaten Cubes an, und vergib eine Nummer
for zeile:=0 to anzzeilen-1 do begin
for spalte:=0 to anzspalten-1 do begin
if APA[spalte,zeile].farbe=clYellow then begin
if APA[spalte,zeile].interessant=true then begin
//Speichere Required Cubes
//Merke dir die Required Cubes
MyReqCubes.Add(auffuellen(inttostr(spalte),10)+auffuellen(inttostr(zeile),10));
end;
end;
end;//end of spalte
end;//end of zeilen
merkcosts:=-1;merkpos:=-1;
for zahler:=0 to MerkmatCubesfertig.Count-1 do begin
NewStringList:=MerkmatCubesfertig.items[zahler];
MyMatCubes.Clear;
MyMatCubes.AddStrings(NewStringList);
merkcosts2:=berechneKostenGesamt(MyMatCubes,MyReqCubes,true);
Listbox1.Items.Add(inttostr(zahler)+' Kosten: '+floattostr(merkcosts2));
listbox1.Items.Add('******************');
APA_Show_Process.ausgabe('Set '+inttostr(zahler+1)+' has costs of
'+floattostr(merkcosts2));
- 338 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if (merkcosts=-1) or (merkcosts>merkcosts2) then begin
Listbox1.items.add('Selected');
merkpos:=zahler;
merkcosts:=merkcosts2;
end;
end;//Ende zahler
if MerkmatCubesfertig.count=0 then
showmessage('The limit is to low. It is not possible to materialize a cube.');
finally
MyReqCubes.Free;
MyMatCubes.Free;
end;
{*********************************************************}
{Ende 3 Berechne die Gesamtkosten für jedes Set}
{*********************************************************}
{*********************************************************}
{4. Materialisiere jenes Set mit den minimalen Kosten}
{*********************************************************}
if (merkpos<>-1)and(stop=false) then begin
APA_Show_Process.ausgabe(inttostr(merkpos+1)+' sets minimizes the costs');
NewStringList:=MerkMatCubesfertig.items[merkpos];
for zahler:=0 to NewStringList.Count-1 do begin
matcount:=matcount+1;
APA[strtoint(copy(NewStringList[zahler],1,10)),strtoint(copy(NewStringList[zahler]
,11,10))].materalisieren:=true;
APA[strtoint(copy(NewStringList[zahler],1,10)),strtoint(copy(NewStringList[zahler]
,11,10))].matcount:=matcount;
end;
end;
{*********************************************************}
{Ende 4 Materialisiere jenes Set mit den minimalen Kosten}
{*********************************************************}
finally
Try
//Freigeben der Daten
for zahler:=0 to MerkMatCubes.Count-1 do begin
NewStringList:=MerkMatCubes[zahler];
NewStringList.Free;
end;
for zahler:=0 to MerkMatCubesfertig.Count-1 do begin
NewStringList:=MerkMatCubesfertig[zahler];
NewStringList.Free;
end;
MerkMatCubes.Free;
MerkMatCubesfertig.Free;
MatCubes.Free;
PossibleCubes.Free;
except
end;
end;
finally
APA_Grid.Enabled:=true;
if APA_Show_Process.Visible=true then
APA_Show_Process.ButtonCancel.Caption:='Close';
CloseFile(fKosten);
materialzeichnen;
APAGrid.Repaint;
showmessage('Ready');
- 339 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end;
end;
procedure TAPA_Grid.APAGridClick(Sender: TObject);
var counter:longint;
var NewItem: TMenuItem;
begin
if (zellespalte<>-1) and(zellezeile<>-1) then begin
klickspalte:=-1;
klickzeile:=-1;
if (Remove_Redundancy.Checked=false)or
((Remove_Redundancy.Checked=true)and(APA[zellespalte,zellezeile].farbe=clYellow)) then
begin;
langbezpopup.Items.Clear;
for counter:=0 to anzd-1 do begin;
NewItem:=TMenuItem.Create(self);
NewItem.Caption:=APA[zellespalte,zellezeile].langbez[counter];
langbezpopup.Items.Add(NewItem);
end;
langbezpopup.Popup(Mouse.CursorPos.x,Mouse.CursorPos.Y);
end;
end;
end;
procedure TAPA_Grid.GridpopupPopup(Sender: TObject);
var g:longint;
begin
if ((zellespalte<>-1)and(zellezeile<>-1))
then begin;
For g:=0 to Gridpopup.Items.Count-1 do Gridpopup.Items[g].Visible:=true;
if Showpossiblecubes2.Visible=false then begin
Showpossiblecubes1.Visible:=false;
Removepossiblecubes1.Visible:=true;
end else
begin
Showpossiblecubes1.Visible:=true;
Removepossiblecubes1.Visible:=false;
end;
if Showdeterministicsolution2.Visible=false then begin
Showdeterministicsolution1.Visible:=false;
Removedeterministicsolution1.Visible:=true;
end else begin
Showdeterministicsolution1.Visible:=true;
Removedeterministicsolution1.Visible:=false;
end;
if ((APA[zellespalte,zellezeile].farbe=clYellow)) then
begin;
NoCubeselected1.Visible:=false;
Redundantcube1.Visible:=false;
Showderivatives1.Visible:=true;
Showredundancyfreecube1.Visible:=false;
n3.Visible:=false;
if APA[zellespalte,zellezeile].interessant=true then begin
Required1.Visible:=false;Notrequired1.Visible:=true;
end
else
begin
Required1.Visible:=true;Notrequired1.Visible:=false;
//Festlegen der Required Spalten
for g:=0 to Required1.Count-1 do begin
if g<APA_Parameter.APA_Degrees.Count then begin
- 340 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Required1.Items[g].Visible:=true;
Required1.Items[g].Caption:=APA_Parameter.APA_Degrees.Items[g];
end else begin
Required1.Items[g].Visible:=false;
end;
end;
end;
if APA[zellespalte,zellezeile].materalisieren=true then begin
Materialize1.Visible:=false;Dematerialize1.Visible:=true;
end
else
begin
Materialize1.Visible:=true;Dematerialize1.Visible:=false;
end;
end else begin
NoCubeselected1.Visible:=false;
Redundantcube1.Visible:=true;n3.Visible:=true;
Required1.Visible:=false;Notrequired1.Visible:=false;
Materialize1.Visible:=false; Dematerialize1.Visible:=false;
Showderivatives1.Visible:=false;
Showredundancyfreecube1.Visible:=true;
end;
end else begin
For g:=0 to Gridpopup.Items.Count-1 do Gridpopup.Items[g].Visible:=false;
NoCubeselected1.Visible:=true;
end;
end;
procedure TAPA_Grid.Removematerializedcubes1Click(Sender: TObject);
begin
Button_remove_materialized_cubes.Click;
end;
procedure TAPA_Grid.Removederivatives1Click(Sender: TObject);
begin
Button_remove_derivatives.Click;
end;
procedure TAPA_Grid.Removerequiredcubes1Click(Sender: TObject);
begin
Button_remove_required_cubes.Click;
end;
procedure TAPA_Grid.Removeredundancy1Click(Sender: TObject);
begin
if Remove_Redundancy.Checked=false then
Remove_Redundancy.Checked:=true else
Remove_Redundancy.checked:=false;
Remove_RedundancyClick(self);
end;
procedure TAPA_Grid.Button3Click(Sender: TObject);
var zeile,spalte, aktzeile,aktspalte:longint;
var x,aktpos,maxpos,anzcube,reqcube, anzderivative,pos,cubepos:longint;
var zahler, zahler2:longint;
var istok:boolean;
var ende:boolean;
var kostenmerk,Kostenmerkmin:Extended;
var neustarten, Alwaysspacemaxreached:boolean;
var Countliste:array of Longint;
var GeneriereListe,GeneriereReqListe:TStringList;
begin
assignfile(fMatCubes,'C:\APADIR\DATA\MatCubes.dat');
assignfile(fReqCubes,'C:\APADIR\DATA\ReqCubes.dat');
assignfile(fMerkkosten,'C:\APADIR\DATA\Merkkosten.dat');
assignfile(fCounter,'C:\APADIR\DATA\Counter.dat');
assignfile(fCountermerk,'C:\APADIR\DATA\Countermerk.dat');
- 341 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
assignfile(fCubes,'C:\APADIR\DATA\Cubes.dat');
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');
{$i-}
reset(fKosten);
{$i+}
if ioresult<>0 then begin; showmessage('cost database error ');exit;end;
assignfile(fCubes,'C:\APADIR\DATA\Cubes.dat');
Removedeterministicsolution1Click(self);
mustsave:=true;
APA_Show_Process.show;
Application.ProcessMessages;
APA_Grid.Enabled:=false;
GeneriereReqListe:=TStringList.Create();
try
{Rechne alle möglichen Kombinationen durch, welche im Bereich des Maximum sind}
// Mache das über eine Temporäre Datei auf der Festplatte
// ist zwar langsamer, aber bei großen Rechnungen hängt sich der Rechner nicht auf.
with APA_Application do begin
APA_Dialog.APA_Text.Caption:='Do you want to restart?';
if permutation=true then begin
if APA_Dialog.showmodal=mryes then
neustarten:=true else neustarten:=false;
end else neustarten:=true;
{1. Vorbereitungen für die Permutation}
aktpos:=0;permutation:=true;
if neustarten=true then begin;
alwaysspacemaxreached:=false;
{$i-}
rewrite(fCubes);
{$i+}
if ioresult<>0 then begin; showmessage('Cubes database error ');exit;end;
{$i-}
rewrite(fReqCubes);
{$i+}
if ioresult<>0 then begin; showmessage('ReqCubes database error ');exit;end;
{$i-}
rewrite(fCounter);
{$i+}
if ioresult<>0 then begin; showmessage('Counter database error ');exit;end;
{$i-}
rewrite(fMerkkosten);
{$i+}
if ioresult<>0 then begin; showmessage('ReqCubes database error ');exit;end;
try
seek(fMerkkosten,0);
vMerkkosten.Lfnr:=0;
vMerkkosten.Kosten:=0;
write(fMerkkosten,vMerkkosten);
APA_Show_Process.ausgabe('Search for possible cubes...');
anzcube:=0; reqcube:=0;
//Lege alle nicht redundaten Cubes an, und vergib eine Nummer
for zeile:=0 to anzzeilen-1 do begin
for spalte:=0 to anzspalten-1 do begin
if APA[spalte,zeile].farbe=clYellow then begin
if APA[spalte,zeile].interessant=True then begin
anzcube:=anzcube+1;
seek(fCubes,anzcube-1);
- 342 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
vCubes.Lfnr:=anzcube;
vCubes.Spalte:=spalte;
vCubes.Zeile:=zeile;
vCubes.Required:=1;
write(fCubes,vCubes);
APA_Show_Process.ausgabe('Add Cube:
('+inttostr(spalte)+':'+inttostr(zeile)+')');
end else begin
anzderivative:=0;
for aktzeile:=0 to anzzeilen-1 do begin
for aktspalte:=0 to anzspalten-1 do begin
if (APA[aktspalte,aktzeile].farbe=clYellow)and
(APA[aktspalte,aktzeile].interessant=true) then begin
if isderivat(spalte,zeile,aktspalte,aktzeile) then begin
anzderivative:=anzderivative+1;
end;
end;
end;
end;
if anzderivative>0 then begin
anzcube:=anzcube+1;
seek(fCubes,anzcube-1);
vCubes.Lfnr:=anzcube;
vCubes.Spalte:=spalte;
vCubes.Zeile:=zeile;
vCubes.Required:=1;
write(fCubes,vCubes);
APA_Show_Process.ausgabe('Add Cube:
('+inttostr(spalte)+':'+inttostr(zeile)+')');
end;
end;
if APA[spalte,zeile].interessant=true then begin
//Speichere Required Cubes
//Merke dir die Required Cubes
reqcube:=reqcube+1;
seek(fReqCubes,reqcube-1);
vReqCubes.Lfnr:=reqcube;
vReqCubes.Spalte:=spalte;
vReqCubes.Zeile:=zeile;
write(fReqCubes,vReqCubes);
end;
end;
end;//end of spalte
end;//end of zeilen
finally
CloseFile(fCubes);
CloseFile(fReqCubes);
CloseFile(fCounter);
CloseFile(fMerkkosten);
end;
end//von neustarten
else begin
alwaysspacemaxreached:=false;
end;
{$i-}
reset(fCubes);
{$i+}
if ioresult<>0 then begin; showmessage('Cubes database error ');exit;end;
try
anzcube:=filesize(fCubes);
Setlength(Countliste,anzcube);
MemoryCubes:=nil;
- 343 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
setlength(MemoryCubes,anzcube);
pos:=0;
repeat;
if (filesize(fCubes)>0) then begin
seek(fCubes,pos);
read(fCubes,vCubes);
x:=round(vCubes.lfnr)-1;
Memorycubes[x].nr:=round(vCubes.lfnr);
Memorycubes[x].spalte:=vCubes.Spalte;
Memorycubes[x].zeile:=vCubes.Zeile;
end;
pos:=pos+1;
until pos>=filesize(fCubes);
{$i-}
reset(fReqCubes);
{$i+}
if ioresult<>0 then begin; showmessage('ReqCubes database error ');exit;end;
try
MemoryreqCubes:=nil;
setlength(MemoryReqCubes,filesize(fReqCubes));
MemoryReqCubescount:=filesize(fReqCubes);
pos:=0;
repeat;
if (filesize(fReqCubes)>0) then begin
seek(fReqCubes,pos);
read(fReqCubes,vReqCubes);
x:=round(vReqCubes.Lfnr)-1;
MemoryReqCubes[x].spalte:=vReqCubes.Spalte;
MemoryReqCubes[x].zeile:=vReqCubes.Zeile;
end;
pos:=pos+1;
until (pos>=filesize(fReqCubes));
for x:=0 to MemoryReqCubescount-1 do begin
GeneriereReqListe.Add(auffuellen(inttostr(MemoryReqCubes[x].spalte),10)+auffuellen
(inttostr(MemoryReqCubes[x].zeile),10));
end;
APA_Show_Process.ausgabe(inttostr(anzcube)+' Cubes found');
finally
CloseFile(fReqCubes);
end;
finally
CloseFile(fCubes);
end;
Countliste:=nil;
Setlength(Countliste,anzcube+1);
MerkeListe:=nil;
SetLength(Merkeliste,anzcube);
if neustarten=true then begin
//Zuerst alle 0 setzten
for x:=0 to anzcube-1 do Countliste[x]:=0;
maxpos:=0;
Countliste[0]:=1;
cubepos:=Countliste[0];
kostenmerkmin:=0;
end// of neustarten
else begin
for x:=0 to anzcube-1 do Countliste[x]:=0;
- 344 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
//Laden der Cubes
{$i-}
reset(fCounter);
{$i+}
if ioresult<>0 then begin; showmessage('ReqCubes database error ');exit;end;
try
maxpos:=-1;pos:=0;
repeat;
if (filesize(fCounter)>0) then begin
seek(fCounter,pos);
read(fCounter,vCounter);
if vcounter.Lfnr<>-1 then begin
maxpos:=maxpos+1;
x:=round(vCounter.Lfnr);
Countliste[x]:=round(vCounter.nr);
if countliste[x]=0 then countliste[x]:=1;
end;
end else begin
//Feststellen von alwaysspacemaxreached
if vcounter.nr=1 then
alwaysspacemaxreached:=true else
alwaysspacemaxreached:=false;
end;
pos:=pos+1;
until pos>=filesize(fCounter);
cubepos:=Countliste[0]
finally
CloseFile(fCounter);
end;
{$i-}
reset(fMerkkosten);
{$i+}
if ioresult<>0 then begin; showmessage('Merkkosten database error ');exit;end;
try
seek(fMerkkosten,0);read(fMerkkosten,vMerkkosten);
kostenmerkmin:=vMerkkosten.Kosten;
finally
CloseFile(fMerkkosten);
end;
end;
{Ende 1. Vorbereitungen für die Permutation}
if anzcube>0 then begin
//Kombinatorik
if neustarten=true then begin
Countliste[0]:=1;
aktpos:=0;maxpos:=0;
end//neustarten
else APA_Show_Process.ausgabe('*** Start Restart ***');
{2. Beginn der Permutationsschleife}
ende:=false;
while (ende=false)and (stop=false) do begin
repeat;
Application.processmessages;
if APA_Show_Process.GroupBox1.tag=1 then begin
APA_Show_Process.GroupBox1.tag:=0;
//Geheimticker
for x:=0 to maxpos do begin
- 345 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
countliste[x]:=1;
end;
maxpos:=maxpos+1;
countliste[maxpos]:=1;
end;
if APA_Show_Process.GroupBox1.tag=-1 then begin
APA_Show_Process.GroupBox1.tag:=0;
//Geheimticker
countliste[maxpos]:=0;
maxpos:=maxpos-1;
for x:=0 to maxpos do begin
countliste[x]:=1;
end;
end;
//Hüpfe nach links, wenn möglich
// ausser bei Cube max dann nach rechts
if cubepos>anzcube then begin
//Hüpfe nach rechts
//Speichere aktuelle Pos
cubepos:=1;
Countliste[aktpos]:=cubepos;
aktpos:=aktpos+1;
if aktpos>maxpos then maxpos:=aktpos;
if aktpos<anzcube then begin
repeat;
if cubepos>anzcube then begin
cubepos:=1;
Countliste[aktpos]:=cubepos;
aktpos:=aktpos+1;
if aktpos>maxpos then maxpos:=aktpos;
end;
if Countliste[aktpos]=0 then begin
//Neue Zählung
if (alwaysspacemaxreached=true)and(Alwaysspacemaxbeachten1.Checked=true) then
ende:=true;
cubepos:=1;
Countliste[aktpos]:=cubepos;
alwaysspacemaxreached:=true;
end else begin
//Springe auf gespeicherte Position
Countliste[aktpos]:=Countliste[aktpos]+1;
cubepos:=Countliste[aktpos];
end;
until (cubepos<=anzcube);
if (cubepos<>anzcube) then begin;
//Setze den Zähler ganz links auf 0
cubepos:=1;aktpos:=0;Countliste[aktpos]:=cubepos;
end;
//Er springt wieder in die Startzeile zurück
//Alle 50000 Einträge lösche die Anzeigeliste um Speicher zu schonen
if APA_Show_Process.APA_Protocoll.Items.Count>50000 then
APA_Show_Process.APA_Protocoll.Items.Clear;
if stop=true then stop:=false;
//Hier soll nicht abgebrochen werden
end//von <anzwurfel
else ende:=true;
end else begin
//Hüpfe ganz nach Links
aktpos:=0;
istok:=true;
//Feststellen,ob nichts gleich
for zahler:=0 to maxpos do begin
- 346 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
//Es wird von der Position bis zum Ende kontrolliert
//da die ersten Positionen schon verglichen wurden
for zahler2:=zahler to maxpos do begin
if ((zahler2<>zahler)and
(Countliste[zahler2]=Countliste[zahler]))
then
istok:=false;
end;
end;
if istok=true then begin
//Speichern
//Stelle fest ob spacemax erfüllt.
//Wenn ja berechne Kosten
spaceleftfirstcubes:=strtofloat(APA_Parameter.APA_Thomas_spacemax.text);
spaceleft:=strtofloat(APA_Parameter.APA_Thomas_spacemax.text);
for x:=0 to maxpos do begin
APA_Show_Process.ausgabe(' '+inttostr(countliste[x]));
if countliste[x]>0 then begin
spaceleft:=spaceleft(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(MemoryCubes[Coun
tliste[x]-1].spalte,MemoryCubes[Countliste[x]-1].zeile));
if x<>0 then begin
//Rechne den Speicherplatz ohne die letzte Ebene aus.
//Wenn dieser überschritten kann der durchlauf der letzten Ebene gestoppt werden
spaceleftfirstcubes:=spaceleftfirstcubes(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(MemoryCubes[Coun
tliste[x]-1].spalte,MemoryCubes[Countliste[x]-1].zeile));
end;
end;
end;//Ende von x
//Wenn überschritten setzt den Zähler der ersten auf max
if (spaceleftfirstcubes<0)and(Alwaysspacemaxbeachten1.Checked=true) then begin
if aktpos=0 then
Countliste[0]:=anzcube-1;
APA_Show_Process.ausgabe(' >>> Jump to next because spaceleft is
'+floattostr(spaceleftfirstcubes));
end;
//Speichern
APA_Show_Process.ausgabe('Adding Seq ');
if spaceleft>0 then begin
GeneriereListe:=TStringList.create();
try
for x:=0 to maxpos do begin
if countliste[x]>0 then begin
GeneriereListe.Add(auffuellen(inttostr(MemoryCubes[countliste[x]1].spalte),10)+auffuellen(inttostr(MemoryCubes[countliste[x]-1].zeile),10));
end;
end;
kostenmerk:=berechneKostenGesamt(GeneriereListe,GeneriereReqListe,true);
finally
GeneriereListe.Free;
end;
if kostenmerk>0 then begin
- 347 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if(kostenmerkmin=0)or(kostenmerkmin>kostenmerk)
then begin;
Alwaysspacemaxreached:=false;
{$i-}
reset(fMerkkosten);
{$i+}
if ioresult<>0 then begin; showmessage('Merkkosten database error ');exit;end;
try
APA_Show_Process.ausgabe('*****************');
APA_Show_Process.ausgabe('Trage ein das Minimum '+floattostr(kostenmerk));
vMerkkosten.Kosten:=kostenmerk;
vMerkkosten.Lfnr:=0;
seek(fMerkkosten,0);write(fMerkkosten,vMerkkosten);
kostenmerkmin:=kostenmerk;
seek(fMerkkosten,1);
vMerkkosten.Lfnr:=1;
vMerkkosten.Kosten:=spaceleft;
write(fMerkkosten,vMerkkosten);
seek(fMerkkosten,2);
vMerkkosten.Lfnr:=2;
vMerkkosten.Kosten:=timeleft;
write(fMerkkosten,vMerkkosten);
finally
CloseFile(fMerkkosten);
end;
//Speichere Counttable
assignfile(fCountermerk,'c:\APADIR\DATA\Countermerk.dat');
{$i-}
rewrite(fCountermerk);
{$i+}
if ioresult<>0 then showmessage('Can not open File Countermerk.dat');
try
for x:=0 to maxpos do begin
seek(fCountermerk,filesize(fCountermerk));
vCountermerk.Lfnr:=x;
vCountermerk.Nr:=Countliste[x];
write(fCountermerk,vCountermerk);
APA_Show_Process.ausgabe('Save Cube Pos:'+floattostr(vCountermerk.Lfnr)+'
Nr:'+floattostr(vCountermerk.Nr));
end;
finally
CloseFile(Fcountermerk);
end;
end;
end else APA_Show_Process.ausgabe('Ist O ');
end// spaceleft>0
else APA_Show_Process.ausgabe('spacemax reached ');
end;//of istok
cubepos:=cubepos+1;
Countliste[aktpos]:=cubepos;
end;//Ende von links
repeat; Application.ProcessMessages; until break=false;
if (stop=true) and (aktpos<>0) then stop:=false;
//Nur in der aktpos stoppen
until (cubepos>anzcube)or (stop=true);
if (stop=true) and (aktpos<>0) then stop:=false;
//Nur in der aktpos stoppen
end;//ende=true;
- 348 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
{Ende 2. Beginn der Permutationsschleife}
//Speichern des aktuellen Cubeliste damit man wieder weiter machen kann.
//speichere aktuelle Position
assignfile(fCounter,'c:\APADIR\DATA\Counter.dat');
{$i-}
rewrite(fCounter);
{$i+}
if ioresult<>0 then showmessage('Can not open File Counter.dat');
try
seek(fCounter,0);
vCounter.Lfnr:=-1;
if vcounter.nr=1 then
if alwaysspacemaxreached=true then vcounter.Nr:=1
else vcounter.Nr:=0;
write(fCounter,vCounter);
for x:=0 to maxpos do begin
seek(fCounter,x+1);
vCounter.Lfnr:=x;
vCounter.Nr:=Countliste[x];
write(fCounter,vCounter);
end;
finally
CloseFile(fcounter);
end;
end;// Wenn es mindestens einen Cube gibt in der Cubeliste
end;//with Apa_Application
finally
CloseFile(fKosten);
GeneriereReqListe.Free;
Showmessage('Ready');
APA_Grid.Enabled:=true;
end;
end;
procedure TAPA_Grid.Algorithm1Click(Sender: TObject);
begin
if permutation=true then begin
Button3.click;
end else begin
APA_Dialog.APA_Text.Caption:='Your last deterministic run was not a permutation. Do
you want do continue? This will delete your last run!';
if APA_Dialog.showmodal=mryes then begin;
Button3.Click;
end;
end;
end;
procedure TAPA_Grid.SearchusingThomasAchsheuristic2Click(Sender: TObject);
begin
Button2.click;
end;
procedure TAPA_Grid.Alogrithm1Click(Sender: TObject);
begin
Button3.Click;
end;
procedure TAPA_Grid.Parameter1Click(Sender: TObject);
begin
APA_Parameter.ShowModal;
end;
function TAPA_Grid.berechneKostenGesamt(MatCubes,ReqCubes:TStringList;
Nullstellen:boolean):Extended;
var x,aktspalte,aktzeile:longint;
var SummeKosten:Extended;
- 349 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
var zahler,counter:longint;
var newcosts:Extended;
var new:String;
var isderivatof:boolean;
var newminderivatspalte,newminderivatzeile:longint;
var spalte,zeile:longint;
begin
// Berechne die Materialisierungskosten
spaceleft:=strtofloat(APA_Parameter.APA_Thomas_spacemax.text);
timeleft:=strtofloat(APA_Parameter.APA_Thomas_timemax.text);
Memorywuerfel:= TStringList.Create; //Erzeuge die Liste der ausgewählten Würfel
SummeKosten:=0;
try
for x:=0 to MatCubes.count-1 do begin
aktspalte:=strtoint(copy(MatCubes[x],1,10));
aktzeile:=strtoint(copy(MatCubes[x],11,10));
spaceleft:=spaceleft(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(aktspalte,aktzei
le));
end;//Ende von x
if (spaceleft>0) then begin
//2. Kosten der Kombination berechnen
SummeKosten:=0;
//2A Ersten Würfel zusetzen
aktspalte:=strtoint(copy(MatCubes[0],1,10));
aktzeile:=strtoint(copy(MatCubes[0],11,10));
if (Userandomcosts1.Checked=true) then begin
newcosts:=getbuild(-1,-1,aktspalte,aktzeile);
end else begin
newcosts:=deltaBftW(aktspalte,aktzeile,false);
end;
SummeKosten:=SummeKosten+newcosts;
new:=auffuellen(inttostr(aktspalte),30);
new:=new+auffuellen(inttostr(aktzeile),30);
Memorywuerfel.Add(new);
listbox1.Items.Add('Add '+new+' build from BFT');
listbox1.Items.Add('that costs '+floattostr(newcosts));
timeleft:=timeleft-newcosts;
//Erster Würfel zugesetzt Ende
//2B Zusätzlich Würfel zusetzen
for x:=1 to MatCubes.count-1 do begin
aktspalte:=strtoint(copy(MatCubes[x],1,10));
aktzeile:=strtoint(copy(MatCubes[x],11,10));
//? Kann der neue Würfel aus einem bereits materialisierten Würfel abgeleitet
werden?
isderivatof:=false;
for counter:=0 to Memorywuerfel.count-1 do begin
New:=Memorywuerfel[counter];
if
isderivat(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),
aktspalte,aktzeile) then begin;
isderivatof:=true;
end;
end;
if isderivatof=true then begin
//Yes leite aus diesem Würfel ab
newminderivatspalte:=GetMinDerivatOfSpalte(aktspalte,aktzeile,false);
newminderivatzeile:=GetMinDerivatOfZeile(aktspalte,aktzeile,false);
- 350 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if (Userandomcosts1.Checked=true) then begin
newcosts:=getbuild(newminderivatspalte,newminderivatzeile,
aktspalte,aktzeile);
end else begin
newcosts:=deltaVW(newminderivatspalte,newminderivatzeile,
aktspalte,aktzeile,false);
end;
SummeKosten:=SummeKosten+newcosts;
new:=auffuellen(inttostr(aktspalte),30);
new:=new+auffuellen(inttostr(aktzeile),30);
listbox1.Items.Add('Add '+new+' build from ('+
inttostr(newminderivatspalte)+':'+
inttostr(newminderivatzeile)+')');
listbox1.Items.Add('that costs '+
floattostr(newcosts));
Memorywuerfel.Add(new);
if Userandomcosts1.Checked=true then begin
timeleft:=timeleft-newcosts;
end else
begin
timeleft:=timeleft(strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(gettupel(newminderivatspalte,ne
wminderivatzeile)+(2*gettupel(aktspalte,aktzeile)))+
+strtofloat(APA_Parameter.APA_Thomas_timecpu.text)*gettupel(aktspalte,aktzeile)*lo
g2(gettupel(aktspalte,aktzeile))+
strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*gettupel(aktspalte,aktzeile));
end;
end else begin
//No leite aus dem BFT ab
if (Userandomcosts1.Checked=true) then begin
newcosts:=getbuild(-1,-1,aktspalte,aktzeile);
end else begin
newcosts:=deltaBftW(aktspalte,aktzeile,false);
end;
SummeKosten:=SummeKosten+newcosts;
new:=auffuellen(inttostr(aktspalte),30);
new:=new+auffuellen(inttostr(aktzeile),30);
listbox1.Items.Add('Add '+new+' build from BFT');
listbox1.Items.Add('that costs '+floattostr(newcosts));
Memorywuerfel.Add(new);
if Userandomcosts1.Checked=true then begin
timeleft:=timeleft-newcosts;
end else begin
timeleft:=timeleft-(strtofloat(APA_Parameter.APA_Thomas_timeio.text)*(gettupel(1,-1)+(2*gettupel(aktspalte,aktzeile)))+
+strtofloat(APA_Parameter.APA_Thomas_timecpu.text)*gettupel(aktspalte,aktzeile)*lo
g2(gettupel(aktspalte,aktzeile))+
strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*gettupel(aktspalte,aktzeile));
end;
end;
end;//Ende von x
Listbox1.Items.Add('Die Würfel sind');
for counter:=0 to Memorywuerfel.Count-1 do begin
Listbox1.Items.add(Memorywuerfel[counter]);
end;
{zahler:=0;
EntferneausDiss
repeat;
If MatCubes.count>zahler then begin
//Merke Ausgangscube
merkcube:=zahler;
merkspalte:=strtoint(copy(MatCubes[zahler],1,10));
merkzeile:=strtoint(copy(MatCubes[zahler],11,10));
- 351 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
//Kontrolliere alle Vorgänger des aktuellen Cube
zahler2:=0;
merkderivat:=-1;merkderivatspalte:=-1;merkderivatzeile:=-1;
repeat;
if (MatCubes.count>zahler2) then begin
if
((strtoint(copy(MatCubes[zahler2],1,10))<>merkspalte)or(strtoint(copy(MatCubes[zah
ler2],11,10))<>merkzeile))
and(merkcube>zahler2)//Verhindert, dass nur Cubes, welche früher mat. wurden
beachtet werden
then begin
if
(isderivat(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],
11,10)),
merkspalte,merkzeile)=true)
then begin;
//Wenn kosten kleiner als bereits gemerkter dann merken
if (Userandomcosts1.Checked=true) then begin
if (merkderivat=-1) or (
(getbuild(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],1
1,10)),
merkspalte,merkzeile)<
getbuild(merkderivatspalte,merkderivatzeile,merkspalte,merkzeile)))
then begin
merkderivat:=zahler2;
merkderivatspalte:=strtoint(copy(MatCubes[zahler2],1,10));
merkderivatzeile:= strtoint(copy(MatCubes[zahler2],11,10));
end;
end else begin
if (merkderivat=-1) or (
(deltaVW(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],11
,10)),
merkspalte,merkzeile,false)<
deltaVW(merkderivatspalte,merkderivatzeile,merkspalte,merkzeile,false)))
then begin
merkderivat:=zahler2;
merkderivatspalte:=strtoint(copy(MatCubes[zahler2],1,10));
merkderivatzeile:= strtoint(copy(MatCubes[zahler2],11,10));
end;
end;
end;
end;//spalte<>spalte oder zeile<>zeile
end; //<>Lfnr
zahler2:=zahler2+1;
until (zahler2>MatCubes.count-1)or(zahler2=merkcube);
//Wenn derivat vorhanden erzeuge aus dem Derivat sonst aus BFT
if merkderivat<>-1 then begin
if (Userandomcosts1.Checked=true) then begin
merkcosts:=getbuild(merkderivatspalte,merkderivatzeile,strtoint(copy(MatCubes[zahl
er],1,10)),strtoint(copy(MatCubes[zahler],11,10)));
end else begin
merkcosts:=deltaVW(merkderivatspalte,merkderivatzeile,strtoint(copy(MatCubes[zahle
r],1,10)),strtoint(copy(MatCubes[zahler],11,10)),false);
end;
SummeKosten:=SummeKosten+merkcosts;
listbox1.Items.Add('Add
'+inttostr(strtoint(copy(MatCubes[zahler],1,10)))+':'+inttostr(strtoint(copy(MatCu
bes[zahler],11,10)))+' erzeugt aus '+
inttostr(merkderivatspalte)+':'+inttostr(merkderivatzeile));
listbox1.Items.Add('costs are '+floattostr(merkcosts));
//Berechne spaceleft und timeleft
- 352 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if (Userandomcosts1.Checked=false) then begin
timeleft:=timeleft-(strtofloat(APA_Parameter.APA_Thomas_timeio.text)*
(gettupel(-1,1)+(2*gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler
],11,10)))))+
+strtofloat(APA_Parameter.APA_Thomas_timecpu.text)*
gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler],11,1
0)))
*log2(gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler
],11,10))))+
strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*
gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler],11,1
0))));
spaceleft:=spaceleft(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*
gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler],11,1
0))));
end else begin
timeleft:=timeleftmerkcosts;
spaceleft:=spaceleft(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*
gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler],11,1
0))));
end;
end else begin
if (Userandomcosts1.Checked=true) then begin
merkcosts:=getbuild(-1,1,strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler],11,10)));
end else begin
merkcosts:=deltaBftW(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[
zahler],11,10)),false);
end;
SummeKosten:=SummeKosten+merkcosts;
listbox1.Items.Add('Add
'+inttostr(strtoint(copy(MatCubes[zahler],1,10)))+':'+inttostr(strtoint(copy(MatCu
bes[zahler],11,10)))+' erzeugt aus '+
inttostr(-1)+':'+inttostr(-1));
listbox1.Items.Add('costs are '+floattostr(merkcosts));
if (Userandomcosts1.Checked=false) then begin
timeleft:=timeleft-(strtofloat(APA_Parameter.APA_Thomas_timeio.text)*
(gettupel(-1,1)+(2*gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler
],11,10)))))+
+strtofloat(APA_Parameter.APA_Thomas_timecpu.text)*
gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler],11,1
0)))
*log2(gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler
],11,10))))+
strtofloat(APA_Parameter.APA_Thomas_timestore.Text)*
- 353 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler],11,1
0))));
spaceleft:=spaceleft(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*
gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler],11,1
0))));
end else begin
timeleft:=timeleftmerkcosts;
spaceleft:=spaceleft(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*
gettupel(strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler],11,1
0))));
end;
end;
end;
zahler:=zahler+1;
until (zahler>MatCubes.count-1);}
//3. Berechne die Abfragekosten
{zahler:=0; //Zahler für ReqCubes
repeat;
if (zahler<ReqCubes.count) then begin
//Abfragekosten addieren
merkderivat:=-1;merkderivatspalte:=-1;merkderivatzeile:=-1;
zahler2:=0;//Zähler für Materialisierte Würfel
repeat;
if (zahler2<MatCubes.Count) then begin
if
(isderivat(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],
11,10)),
strtoint(copy(ReqCubes[zahler],1,10)),strtoint(copy(ReqCubes[zahler],11,10)))=true
)
then begin;
//Wenn kosten kleiner als bereits gemerkter dann merken
if (Userandomcosts1.Checked=true) then begin
if (merkderivat=-1) or
((getbuild(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],
11,10)),strtoint(copy(ReqCubes[zahler],1,10)),strtoint(copy(ReqCubes[zahler],11,10
)))<
getbuild(merkderivatspalte,merkderivatzeile,strtoint(copy(ReqCubes[zahler],1,10)),
strtoint(copy(ReqCubes[zahler],11,10)))))
then begin
merkderivat:=zahler2;
merkderivatspalte:=strtoint(copy(MatCubes[zahler2],1,10));
merkderivatzeile:= strtoint(copy(MatCubes[zahler2],11,10));
end;
end else begin
if (merkderivat=-1) or
((deltaVW(strtoint(copy(MatCubes[zahler2],1,10)),strtoint(copy(MatCubes[zahler2],1
1,10)),strtoint(copy(ReqCubes[zahler],1,10)),strtoint(copy(ReqCubes[zahler],11,10)
),false)<
- 354 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
deltaVW(merkderivatspalte,merkderivatzeile,strtoint(copy(ReqCubes[zahler],1,10)),s
trtoint(copy(ReqCubes[zahler],11,10)),false)))
then begin
merkderivat:=zahler2;
merkderivatspalte:=strtoint(copy(MatCubes[zahler2],1,10));
merkderivatzeile:= strtoint(copy(MatCubes[zahler2],11,10));
end;
end;
end;
end;
zahler2:=zahler2+1;
until (zahler2>MatCubes.count-1);
aktspalte:=strtoint(copy(ReqCubes[zahler],1,10));
aktzeile:=strtoint(copy(ReqCubes[zahler],11,10));
if merkderivat=-1 then begin
//Erzeuge aus BFT
if (Userandomcosts1.Checked=true) then begin
SummeKosten:=SummeKosten+
(getquery(-1,-1,aktspalte,aktzeile)*
APA[aktspalte,aktzeile].gewicht);
listbox1.Items.Add('Query '+inttostr(aktspalte)+':'+inttostr(aktzeile)+'
erzeugt aus '+
inttostr(-1)+':'+inttostr(-1));
listbox1.Items.Add('costs are '+floattostr((getquery(-1,1,aktspalte,aktzeile)*
APA[aktspalte,aktzeile].gewicht)));
end else begin
SummeKosten:=SummeKosten+
(deltaBftW(aktspalte,aktzeile,true)*
APA[aktspalte,aktzeile].gewicht);
listbox1.Items.Add('Query '+inttostr(aktspalte)+':'+inttostr(aktzeile)+'
erzeugt aus '+
inttostr(-1)+':'+inttostr(-1));
listbox1.Items.Add('costs are
'+floattostr((deltaBftW(aktspalte,aktzeile,true)*
APA[aktspalte,aktzeile].gewicht)));
end;
end else begin
//Erzeuge aus dem Derivat
if (Userandomcosts1.Checked=true) then begin
SummeKosten:=SummeKosten+
(getquery(merkderivatspalte,merkderivatzeile,aktspalte,aktzeile)*
APA[aktspalte,aktzeile].gewicht);
listbox1.Items.Add('Query '+inttostr(aktspalte)+':'+inttostr(aktzeile)+' erzeugt
aus '+
inttostr(merkderivatspalte)+':'+inttostr(merkderivatzeile));
listbox1.Items.Add('costs are
'+floattostr((getquery(merkderivatspalte,merkderivatzeile,aktspalte,aktzeile)*
APA[aktspalte,aktzeile].gewicht)));
end else begin
SummeKosten:=SummeKosten+
(deltaVW(merkderivatspalte,merkderivatzeile,aktspalte,aktzeile,true)*
APA[aktspalte,aktzeile].gewicht);
listbox1.Items.Add('Query '+inttostr(aktspalte)+':'+inttostr(aktzeile)+' erzeugt
aus '+
inttostr(merkderivatspalte)+':'+inttostr(merkderivatzeile));
listbox1.Items.Add('costs are
'+floattostr((deltaVW(merkderivatspalte,merkderivatzeile,aktspalte,aktzeile,true)*
APA[aktspalte,aktzeile].gewicht)));
end;
end;
end;
- 355 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
zahler:=zahler+1;
until (zahler>ReqCubes.count-1); }
{3.Zusetzen der Querykosten}
for zahler:=0 to ReqCubes.count-1 do begin;
spalte:=strtoint(copy(ReqCubes[zahler],1,10));
zeile:=strtoint(copy(ReqCubes[zahler],11,10));
isderivatof:=false;
for counter:=0 to Memorywuerfel.Count-1 do begin
New:=Memorywuerfel[counter];
if
isderivat(strtoint(copy(new,1,30)),strtoint(copy(new,31,30)),
spalte,zeile) then begin;
isderivatof:=true;
end;
end;
if isderivatof=true then begin
newminderivatspalte:=GetMinDerivatOfSpalte(spalte,zeile,true);
newminderivatzeile:=GetMinDerivatOfZeile(spalte,zeile,true);
if (Userandomcosts1.Checked=true) then begin
newcosts:= ((getquery(newminderivatspalte,newminderivatzeile,
spalte,zeile))
*APA[spalte,zeile].gewicht);
end else begin
newcosts:= ((deltaVW(newminderivatspalte,newminderivatzeile,
spalte,zeile,true))
*APA[spalte,zeile].gewicht);
end;
SummeKosten:=SummeKosten+newcosts;
listbox1.Items.Add('Reqcosts ('+inttostr(spalte)+':'+inttostr(zeile)+')');
Listbox1.items.add('Query from ('+inttostr(newminderivatspalte)+':'+
inttostr(newminderivatzeile)+')');
listbox1.Items.Add('that costs '+floattostr(newcosts));
end else begin
if (Userandomcosts1.Checked=true) then begin
newcosts:=((getquery(-1,-1,spalte,zeile))
*APA[spalte,zeile].gewicht);
end else begin
newcosts:=((deltaBftW(spalte,zeile,true))
*APA[spalte,zeile].gewicht);
end;
SummeKosten:=SummeKosten+ newcosts;
listbox1.Items.Add('Reqcosts ('+inttostr(spalte)+':'+inttostr(zeile)+')');
Listbox1.Items.Add('Query from BFT');
listbox1.Items.Add('that costs '+floattostr(newcosts));
end;
end;//of zahler
if (timeleft<0) then begin;
If Nullstellen=true then Summekosten:=0;APA_Show_Process.ausgabe('Timemax reached');
end;
end; // von Spaceleft>0
finally
Result:=SummeKosten;
Memorywuerfel.free;
end;
end;
procedure TAPA_Grid.Showcosts1Click(Sender: TObject);
- 356 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
var zeile,spalte, zahler:longint;
var MatCubes,ReqCubes, MatCubesSorted:TStringList;
var merkeRandom:boolean;
begin
if matcount>0 then begin
//Berechne die Kosten der aktuellen Materialsierung
//auf der Basis der Zufallskosten
//Nur getbuild
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');
{$i-}
reset(fKosten);
{$i+}
if ioresult<>0 then begin; showmessage('cost database error ');exit;end;
Listbox1.Items.Add('');
Listbox1.Items.Add('Berechne Kosten');
Listbox1.Items.Add('');
ReqCubes:=TStringList.Create;
ReqCubes.Clear;
MatCubes:=TStringList.Create;
MatCubes.Clear;
MatCubesSorted:=TStringList.Create;
MatCubesSorted.Clear;
merkerandom:=Userandomcosts1.Checked;
Userandomcosts1.Checked:=true;
try
//Lege alle nicht redundaten Cubes an, und vergib eine Nummer
for zeile:=0 to anzzeilen-1 do begin
for spalte:=0 to anzspalten-1 do begin
if APA[spalte,zeile].farbe=clYellow then begin
if APA[spalte,zeile].interessant=true then begin
//Speichere Required Cubes
//Merke dir die Required Cubes
ReqCubes.Add(auffuellen(inttostr(spalte),10)+auffuellen(inttostr(zeile),10));
end;
if APA[spalte,zeile].materalisieren=true then begin
//Speichere Mat Cubes
//Merke dir die MatCubes
MatCubes.Add(auffuellen(inttostr(spalte),10)+auffuellen(inttostr(zeile),10));;
end;
end;
end;//end of spalte
end;//end of zeilen
for zahler:=0 to MatCubes.count-1 do MatCubesSorted.Add('free');
for zahler:=0 to MatCubes.Count-1 do begin
MatCubesSorted[APA[strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler],
11,10))].matcount-1]:=
MatCubes[zahler];
end;
showmessage('Costs: '+floattostr(berechneKostenGesamt(MatCubesSorted,ReqCubes,false))+';
Time left: '+
floattostr(timeleft)+'; Space left: '+floattostr(spaceleft));
finally
MatCubes.Free;
ReqCubes.Free;
MatCubesSorted.Free;
Userandomcosts1.Checked:=merkerandom;
- 357 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
CloseFile(fKosten);
end;
end //of matcount
else showmessage('No materialized cubes selected');
end;
function TAPA_Grid.GetRightOrdertom(Listecubes:TStringList):TStringList;
type Knotendeklationszeiger= ^Knotendeklaration;
Knotendeklaration =
record
Knoten:longint;
spalte:longint;
zeile:longint;
MaxAbstand:Extended;
Parent:longint;
end;
var Knoten, Knoten2, Knoten3 , Knotenmerk:Knotendeklationszeiger;
var Innere_Knoten, Randknoten:TList;
var zahler, zahler2, zahler3, zahlermerk:longint;
var costmerk, Kostengewinn:Extended;
var {Parent,} Parentvonderivat:longint;
var {parentcostmerk,} Parentvonderivatcostmerk:Extended;
begin
//Erzeuge alle Randknoten und fülle sie mit den Kosten
Randknoten:= TList.Create;
Innere_Knoten:=TList.Create;
try
for zahler:=0 to Listecubes.Count-1 do begin
//Berechne Maxabstand
//Der Maxabstand ist die Kostenverbesserung der Materialisierung der Derivate von
New(Knoten)
//welche noch nicht materialisiert worden sind.
Kostengewinn:=0;
for zahler2:=0 to Listecubes.count-1 do begin
if
(isderivat(strtoint(copy(Listecubes[zahler],1,10)),strtoint(copy(Listecubes[zahler
],11,10)),
strtoint(copy(Listecubes[zahler2],1,10)),strtoint(copy(Listecubes[zahler2],11,10))
)=true) then begin
if (Userandomcosts1.Checked=true) then begin
Kostengewinn:=Kostengewinn+max(0,
(//Da noch kein Würfel materialisiert wurde werden alle vom BFT
erzeugt
getbuild(-1,1,strtoint(copy(Listecubes[zahler2],1,10)),strtoint(copy(Listecubes[zahler2],11,10
))
)
getbuild(
strtoint(copy(Listecubes[zahler],1,10)),strtoint(copy(Listecubes[zahler],11,10)),
strtoint(copy(Listecubes[zahler2],1,10)),strtoint(copy(Listecubes[zahler2],11,10))
)
)
);
end else begin
Kostengewinn:=Kostengewinn+max(0,
(//Da noch kein Würfel materialisiert wurde werden alle vom BFT
erzeugt
deltaBftW(strtoint(copy(Listecubes[zahler2],1,10)),strtoint(copy(Listecubes[zahler
2],11,10)),false
)
deltaVW(
- 358 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
strtoint(copy(Listecubes[zahler],1,10)),strtoint(copy(Listecubes[zahler],11,10)),
strtoint(copy(Listecubes[zahler2],1,10)),strtoint(copy(Listecubes[zahler2],11,10))
,false
)
)
);
end;
end;
end;
New(Knoten);
Knoten^.Knoten:=zahler;
Knoten^.MaxAbstand:=Kostengewinn;
Knoten^.Parent:=-1;
Knoten^.spalte:= strtoint(copy(Listecubes[zahler],1,10));
Knoten^.zeile:=strtoint(copy(Listecubes[zahler],11,10));
Randknoten.Add(Knoten);
end;
//Erzeuge Randknoten Ende
repeat;//So lange durchlaufen, bis die Menge der Randknoten leer
//Finde den Würfel mit dem Minimalen Abstand und setze diesen zu inneren Würfeln zu
zahlermerk:=-1;costmerk:=0;
for zahler:=0 to Randknoten.Count-1 do begin
Knoten:= Randknoten.Items[zahler];
if (Knoten^.MaxAbstand>costmerk) or(zahlermerk=-1) then begin
zahlermerk:=zahler;
costmerk:=Knoten^.MaxAbstand;
end;
end;
//Zusetzen des Würfels zu Inneren Knoten
Knotenmerk:=Randknoten.Items[zahlermerk];
Innere_Knoten.Add(Knotenmerk);
Randknoten.Delete(zahlermerk);
if Randknoten.Count>0 then begin
//Berechne die Kosten neu
//Stelle fest, ob die Randknoten derivate von dem neuen Inneren Knoten sind.
//Wenn ja und die Kosten sind geringer als die vom BFT dann ändere Kosten
//Ist jedoch der neue Cube ein Derivat von dem Randknoten müssen die Kosten neu
berechnet werden
for zahler:=0 to Randknoten.Count-1 do begin
Knoten:=Randknoten.Items[zahler];
if
(isderivat(Knotenmerk^.spalte,Knotenmerk^.zeile,Knoten^.spalte,Knoten^.zeile)=true
)
or
(isderivat(Knoten^.spalte,Knoten^.zeile,Knotenmerk^.spalte,Knotenmerk^.zeile)=true
)
then begin
Kostengewinn:=0;
//Berechne die Derivate
//Durchlaufe alle Randknoten
for zahler2:=0 to Randknoten.Count-1 do begin
Knoten2:=Randknoten.Items[zahler2];
//Stelle fest, ob dieser Randknoten ein Derivat ist
if
(isderivat(Knoten^.spalte,Knoten^.zeile,Knoten2^.spalte,Knoten2.zeile)=true)
and(Knoten^.Knoten<>Knoten2^.Knoten)
then begin
- 359 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
//Finde das Kostenminimale Parent von Knoten2
Parentvonderivat:=-1;
if (Userandomcosts1.Checked=true) then begin
Parentvonderivatcostmerk:=getbuild(-1,-1,Knoten2.spalte,Knoten2^.zeile);
end else begin
Parentvonderivatcostmerk:=deltaBftW(Knoten2.spalte,Knoten2^.zeile,false);
end;
for zahler3:=0 to Innere_Knoten.count-1 do begin
Knoten3:=Innere_Knoten.Items[zahler3];
if
(isderivat(Knoten3^.spalte,Knoten3^.zeile,Knoten2^.spalte,Knoten2^.zeile)=true)
and(Knoten3^.Knoten<>Knotenmerk^.Knoten)and(Knoten3^.Knoten<>Knotenmerk^.Knoten)
then begin
if (Userandomcosts1.Checked=true) then begin
costmerk:=getbuild(Knoten3^.spalte,Knoten3^.zeile,Knoten2^.spalte,Knoten2^.zeile);
end else begin
costmerk:=deltaVW(Knoten3^.spalte,Knoten3^.zeile,Knoten2^.spalte,Knoten2^.zeile,fa
lse);
end;
if (costmerk<Parentvonderivatcostmerk) then begin
Parentvonderivat:=zahler3;
Parentvonderivatcostmerk:=costmerk;
end;
end;
end;//von Zahler3
if parentvonderivat<>-1 then begin
Knoten3:=Innere_Knoten.Items[parentvonderivat];
if (Userandomcosts1.Checked=true) then begin
Kostengewinn:=Kostengewinn+max(0,(
(
getbuild(Knoten3^.spalte,Knoten3^.zeile,Knoten2^.spalte,Knoten2^.zeile)
getbuild(Knoten^.spalte,Knoten^.zeile,Knoten2^.spalte,Knoten2^.zeile)
)
));
end else begin
Kostengewinn:=Kostengewinn+max(0,(
(
deltaVW(Knoten3^.spalte,Knoten3^.zeile,Knoten2^.spalte,Knoten2^.zeile,false)
deltaVW(Knoten^.spalte,Knoten^.zeile,Knoten2^.spalte,Knoten2^.zeile,false)
)
));
end;
end else begin
if (Userandomcosts1.Checked=true) then begin
Kostengewinn:=Kostengewinn+max(0,(
( getbuild(-1,-1,Knoten2^.spalte,Knoten2^.zeile)
getbuild(Knoten^.spalte,Knoten^.zeile,Knoten2^.spalte,Knoten2^.zeile)
)
));
end else begin
Kostengewinn:=Kostengewinn+max(0,(
( deltaBftW(Knoten2^.spalte,Knoten2^.zeile,false)
deltaVW(Knoten^.spalte,Knoten^.zeile,Knoten2^.spalte,Knoten2^.zeile,false)
)
));
end;
end;
end;//End von isderivat
end;
- 360 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end;//Ende von Derivat oder Parent
end;
end;//Randknoten.count>0
until Randknoten.Count=0;//So lange durchlaufen, bis die Menge der Randknoten leer ENDE
finally
Listecubes.Clear;
for zahler:=0 to Innere_Knoten.Count-1 do begin
Knoten:=Innere_Knoten.Items[zahler];
Listecubes.Add(auffuellen(inttostr(Knoten^.spalte),10)+auffuellen(inttostr(Knoten^
.zeile),10));
dispose(Knoten);
end;
for zahler:=0 to Randknoten.Count-1 do begin
Knoten:=Innere_Knoten.Items[zahler];
dispose(Knoten);
end;
Innere_Knoten.free;
Randknoten.free;
Result:=Listecubes;
end;
end;
procedure TAPA_Grid.Button4Click(Sender: TObject);
var
var
var
var
var
var
var
var
var
var
var
var
var
zeile,spalte,aktzeile,aktspalte,anzderivative:longint;
x,aktpos,lang,anzcube,reqcube,pos:longint;
zahler:longint;
seqcounter:Extended;
istok:boolean;
ende:boolean;
kostenmerk,kostenmerkmin:Extended;
neustarten:boolean;
Countliste:array of Longint;
neuespalte:boolean;
alwaysspacemaxreached, geladen:boolean;
st:string;
GeneriereListe, GeneriereReqListe:TStringList;
begin
assignfile(fMatCubes,'C:\APADIR\DATA\MatCubes.dat');
assignfile(fReqCubes,'C:\APADIR\DATA\ReqCubes.dat');
assignfile(fMerkkosten,'C:\APADIR\DATA\Merkkosten.dat');
assignfile(fCounter,'C:\APADIR\DATA\Counter.dat');
assignfile(fCountermerk,'C:\APADIR\DATA\Countermerk.dat');
assignfile(fCubes,'C:\APADIR\DATA\Cubes.dat');
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');
mustsave:=true;
Removedeterministicsolution1Click(self);
{$i-}
reset(fKosten);
{$i+}
if ioresult<>0 then begin; showmessage('cost database error ');exit;end;
APA_Grid.Enabled:=false;
GeneriereReqListe:=TStringList.create();
try
{Rechne alle möglichen Kombinationen durch, welche im Bereich des Maximum sind}
// Mache das über eine Temporäre Datei auf der Festplatte
// ist zwar langsamer, aber bei großen Rechnungen hängt sich der Rechner nicht auf.
- 361 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
with APA_Application do begin
APA_Dialog.APA_Text.Caption:='Do you want to restart?';
if permutation=false then begin
if APA_Dialog.showmodal=mryes then
neustarten:=true else neustarten:=false;
end else neustarten:=true;
Permutation:=false;
lang:=0;alwaysspacemaxreached:=false;seqcounter:=0;
APA_Show_Process.APA_Protocoll.Clear;
APA_Show_Process.show;
Application.ProcessMessages;
if neustarten=true then begin;
APA_Show_Process.ausgabe('Clear Tables ...');
{$i-}
rewrite(fCubes);
{$i+}
if ioresult<>0 then begin; showmessage('Cubes database error ');exit;end;
{$i-}
rewrite(fReqCubes);
{$i+}
if ioresult<>0 then begin; showmessage('ReqCubes database error ');exit;end;
{$i-}
rewrite(fCounter);
{$i+}
if ioresult<>0 then begin; showmessage('Counter database error ');exit;end;
{$i-}
rewrite(fMerkkosten);
{$i+}
if ioresult<>0 then begin; showmessage('ReqCubes database error ');exit;end;
try
seek(fMerkkosten,0);
vMerkkosten.Lfnr:=0;
vMerkkosten.Kosten:=0;
write(fMerkkosten,vMerkkosten);
APA_Show_Process.ausgabe('Search for possible cubes...');
anzcube:=0; reqcube:=0;
//Lege alle nicht redundaten Cubes an, und vergib eine Nummer
for zeile:=0 to anzzeilen-1 do begin
for spalte:=0 to anzspalten-1 do begin
if APA[spalte,zeile].farbe=clYellow then begin
if APA[spalte,zeile].interessant=True then begin
anzcube:=anzcube+1;
seek(fCubes,anzcube-1);
vCubes.Lfnr:=anzcube;
vCubes.Spalte:=spalte;
vCubes.Zeile:=zeile;
vCubes.Required:=1;
write(fCubes,vCubes);
APA_Show_Process.ausgabe('Add Cube:
('+inttostr(spalte)+':'+inttostr(zeile)+')');
end else begin
anzderivative:=0;
for aktzeile:=0 to anzzeilen-1 do begin
for aktspalte:=0 to anzspalten-1 do begin
if (APA[aktspalte,aktzeile].farbe=clYellow)and
(APA[aktspalte,aktzeile].interessant=true) then begin
if isderivat(spalte,zeile,aktspalte,aktzeile) then begin
anzderivative:=anzderivative+1;
end;
end;
end;
- 362 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end;
if anzderivative>0 then begin
anzcube:=anzcube+1;
seek(fCubes,anzcube-1);
vCubes.Lfnr:=anzcube;
vCubes.Spalte:=spalte;
vCubes.Zeile:=zeile;
vCubes.Required:=1;
write(fCubes,vCubes);
APA_Show_Process.ausgabe('Add Cube:
('+inttostr(spalte)+':'+inttostr(zeile)+')');
end;
end;
if APA[spalte,zeile].interessant=true then begin
//Speichere Required Cubes
//Merke dir die Required Cubes
reqcube:=reqcube+1;
seek(fReqCubes,reqcube-1);
vReqCubes.Lfnr:=reqcube;
vReqCubes.Spalte:=spalte;
vReqCubes.Zeile:=zeile;
write(fReqCubes,vReqCubes);
end;
end;
end;//end of spalte
end;//end of zeilen
finally
CloseFile(fCubes);
CloseFile(fReqCubes);
CloseFile(fCounter);
CloseFile(fMerkkosten);
end;
end;//von neustarten
{$i-}
reset(fCubes);
{$i+}
if ioresult<>0 then begin; showmessage('Cubes database error ');exit;end;
try
anzcube:=filesize(fCubes);
Setlength(Countliste,anzcube);
MemoryCubes:=nil;
setlength(MemoryCubes,anzcube);
pos:=0;
repeat;
if (filesize(fCubes)>0) then begin
seek(fCubes,pos);
read(fCubes,vCubes);
x:=round(vCubes.lfnr)-1;
Memorycubes[x].nr:=round(vCubes.lfnr);
Memorycubes[x].spalte:=vCubes.Spalte;
Memorycubes[x].zeile:=vCubes.Zeile;
end;
pos:=pos+1;
until pos>=filesize(fCubes);
{$i-}
reset(fReqCubes);
{$i+}
if ioresult<>0 then begin; showmessage('ReqCubes database error ');exit;end;
try
MemoryreqCubes:=nil;
setlength(MemoryReqCubes,filesize(fReqCubes));
- 363 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
MemoryReqCubescount:=filesize(fReqCubes);
pos:=0;
repeat;
if (filesize(fReqCubes)>0) then begin
seek(fReqCubes,pos);
read(fReqCubes,vReqCubes);
x:=round(vReqCubes.Lfnr)-1;
MemoryReqCubes[x].spalte:=vReqCubes.Spalte;
MemoryReqCubes[x].zeile:=vReqCubes.Zeile;
end;
pos:=pos+1;
until (pos>=filesize(fReqCubes));
for x:=0 to MemoryReqCubescount-1 do begin
GeneriereReqListe.Add(auffuellen(inttostr(MemoryReqCubes[x].spalte),10)+auffuellen
(inttostr(MemoryReqCubes[x].zeile),10));
end;
finally
CloseFile(fReqCubes);
end;
finally
CloseFile(fCubes);
end;
Countliste:=nil;
Setlength(Countliste,anzcube+1);
MerkeListe:=nil;
SetLength(Merkeliste,anzcube);
APA_Show_Process.ausgabe(inttostr(anzcube)+' Cubes found');
if neustarten=true then begin
geladen:=false;
//Zuerst alle 0 setzten
for x:=0 to anzcube do Countliste[x]:=0;
Countliste[0]:=1;
kostenmerkmin:=0;
end// of neustarten
else begin
geladen:=true;
for x:=0 to anzcube-1 do Countliste[x]:=0;
//Laden der Cubes
{$i-}
reset(fCounter);
{$i+}
if ioresult<>0 then begin; showmessage('ReqCubes database error ');exit;end;
try
lang:=-1;pos:=0;
repeat;
if (filesize(fCounter)>0) then begin
seek(fCounter,pos);
read(fCounter,vCounter);
if vcounter.Lfnr<>-1 then begin
lang:=lang+1;
x:=round(vCounter.Lfnr);
Countliste[x]:=round(vCounter.nr);
end;
end else begin
//Feststellen von alwaysspacemaxreached
if vcounter.nr=1 then
alwaysspacemaxreached:=true else
alwaysspacemaxreached:=false;
end;
- 364 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
pos:=pos+1;
until pos>=filesize(fCounter);
finally
CloseFile(fCounter);
end;
{$i-}
reset(fMerkkosten);
{$i+}
if ioresult<>0 then begin; showmessage('Merkkosten database error ');exit;end;
try
seek(fMerkkosten,0);read(fMerkkosten,vMerkkosten);
kostenmerkmin:=vMerkkosten.Kosten;
finally
CloseFile(fMerkkosten);
end;
end;
if anzcube<>0 then begin
//Kombinatorik
if neustarten=true then begin
Countliste[0]:=1;
lang:=0;
end//neustarten
else APA_Show_Process.ausgabe('*** Restart ***');
ende:=false;
repeat;//until (lang>=anzcube)or(ende=true)
//von links nach rechts nummerieren
if geladen=false then begin
//Beim ersten Start nicht ausführen
//wenn geladen wurde
alwaysspacemaxreached:=true;
end// Ende geladen=false
else geladen:=false;
istok:=true;aktpos:=0;
repeat;//until (neuespalte=true)or(ende=true)
neuespalte:=false;
if istok=true then begin;
//Kontrolliere
//Alle 50000 Einträge lösche die Anzeigeliste um Speicher zu schonen
if APA_Show_Process.APA_Protocoll.Items.Count>50000 then
APA_Show_Process.APA_Protocoll.Items.Clear;
seqcounter:=seqcounter+1;
if alwaysspacemaxreached=true then
APA_Show_Process.ausgabe('>>Add Seq: '+floattostr(seqcounter))
else
APA_Show_Process.ausgabe('>Add Seq: '+floattostr(seqcounter));
//Stelle fest ob spacemax erfüllt.
//Wenn ja ordne die Würfel und berechne Kosten
spaceleftfirstcubes:=strtofloat(APA_Parameter.APA_Thomas_spacemax.text);
spaceleft:=strtofloat(APA_Parameter.APA_Thomas_spacemax.text);
for x:=0 to lang do begin
APA_Show_Process.ausgabe('
'+inttostr(countliste[x]));
- 365 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
spaceleft:=spaceleft(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(MemoryCubes[Coun
tliste[x]-1].spalte,MemoryCubes[Countliste[x]-1].zeile));
if x<>0 then begin
//Rechne den Speicherplatz ohne die letzte Ebene aus.
//Wenn dieser überschritten kann der durchlauf der letzten Ebene gestoppt werden
spaceleftfirstcubes:=spaceleftfirstcubes(strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(MemoryCubes[Coun
tliste[x]-1].spalte,MemoryCubes[Countliste[x]-1].zeile));
end;
end;//Ende von x
//Wenn überschritten setzt den Zähler der ersten auf max
if spaceleftfirstcubes<0 then begin
if aktpos=0 then
Countliste[0]:=anzcube;
APA_Show_Process.ausgabe(' >>> Jump to next because spaceleft is
'+floattostr(spaceleftfirstcubes));
end;
if spaceleft>0 then begin
// Nur wenn die Spacemax Bedingung erfüllt weiterrechnen
alwaysspacemaxreached:=false;
for zahler:=0 to lang do begin
MerkeListe[zahler]:=countliste[zahler];
end;
//Berechne Kosten
GeneriereListe:=TStringList.create();
try
for x:=0 to lang do begin
GeneriereListe.Add(auffuellen(inttostr(MemoryCubes[countliste[x]1].spalte),10)+auffuellen(inttostr(MemoryCubes[countliste[x]-1].zeile),10));
end;
for x:=0 to lang do begin
APA_Show_Process.ausgabe('Unsorted: '+inttostr(x)+':
('+inttostr(strtoint(copy(GeneriereListe[x],1,10)))+':'+inttostr(strtoint(copy(Gen
eriereListe[x],11,10)))+')');
end;
APA_Show_Process.ausgabe('Sort Cubes ...');
GeneriereListe:=GetRightOrdertom(GeneriereListe);
for x:=0 to lang do begin
APA_Show_Process.ausgabe('Sorted: '+inttostr(x)+':
('+inttostr(strtoint(copy(GeneriereListe[x],1,10)))+':'+inttostr(strtoint(copy(Gen
eriereListe[x],11,10)))+')');
end;
kostenmerk:=berechneKostenGesamt(GeneriereListe,GeneriereReqListe,true);
finally
GeneriereListe.free;
end;
if kostenmerk>0 then begin
if(kostenmerkmin=0)or(kostenmerkmin>kostenmerk)
then begin;
{$i-}
reset(fMerkkosten);
{$i+}
if ioresult<>0 then begin; showmessage('Merkkosten database error ');exit;end;
try
- 366 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
APA_Show_Process.ausgabe('*****************');
APA_Show_Process.ausgabe('Trage ein das Minimum '+floattostr(kostenmerk));
vMerkkosten.Kosten:=kostenmerk;
vMerkkosten.Lfnr:=0;
seek(fMerkkosten,0);write(fMerkkosten,vMerkkosten);
kostenmerkmin:=kostenmerk;
seek(fMerkkosten,1);
vMerkkosten.Lfnr:=1;
vMerkkosten.Kosten:=spaceleft;
write(fMerkkosten,vMerkkosten);
seek(fMerkkosten,2);
vMerkkosten.Lfnr:=2;
vMerkkosten.Kosten:=timeleft;
write(fMerkkosten,vMerkkosten);
finally
CloseFile(fMerkkosten);
end;
//Speichere Counttable
assignfile(fCountermerk,'c:\APADIR\DATA\Countermerk.dat');
{$i-}
rewrite(fCountermerk);
{$i+}
if ioresult<>0 then showmessage('Can not open File Countermerk.dat');
try
for x:=0 to lang do begin
seek(fCountermerk,filesize(fCountermerk));
vCountermerk.Lfnr:=x;
vCountermerk.Nr:=MerkeListe[x];
write(fCountermerk,vCountermerk);
APA_Show_Process.ausgabe('Save Cube Pos:'+floattostr(vCountermerk.Lfnr)+'
Nr:'+floattostr(vCountermerk.Nr));
end;//Ende von x
finally
CloseFile(fCountermerk);
end;
end;//Ende von if(Minkostcubetable['Kosten']=0) ...
end;//Ende von if kostenmerk>0 then begin
end//von if spacemax>0
else
APA_Show_Process.ausgabe('spacemax reached');
end;// von istok
if countliste[aktpos]>=(anzcube-aktpos) then begin
//Setze alle cubes vom aktpos und kleiner auf 1
Countliste[aktpos]:=1;
x:=aktpos;
repeat;
Countliste[x]:=1;
x:=x-1;
until x=-1;
aktpos:=aktpos+1;
if countliste[aktpos]=0 then neuespalte:=true;
Countliste[aktpos]:=countliste[aktpos]+1;
//Finde den nächsten Cube, welcher nicht das Maximum hat
repeat;
if Countliste[aktpos]>(anzcube-aktpos) then begin
aktpos:=aktpos+1;
if (aktpos>anzcube) then begin
aktpos:=anzcube;
- 367 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
ende:=true;
end;
if countliste[aktpos]=0 then neuespalte:=true;
Countliste[aktpos]:=countliste[aktpos]+1;
end;
until (Countliste[aktpos]<=(anzcube-aktpos))or(ende=true);
//Ende Finde den nächsten Cube, welcher nicht das Maximum hat
//Feststellen, ob alle links richtig sind
x:=aktpos-1;istok:=true;
repeat;
if x>=0 then begin
Countliste[x]:=Countliste[x+1]+1;
end;
x:=x-1;
until x<0;
//Ende Feststellen, ob alle links richtig sind
aktpos:=0;
end //Ende von countliste[aktpos]>= ...
else begin;
Countliste[aktpos]:=countliste[aktpos]+1;
aktpos:=0;
end;
Application.processmessages;
while(break=true) do begin;
Application.processmessages;
end;
if APA_Show_Process.Expertmode1.Checked=true then begin
try
repeat;
st:=inputbox('Countnumber','Countnumber:','');
if st<>'' then begin
x:=strtoint(st);
st:=inputbox('New Countliste','New Countliste:',inttostr(Countliste[x]));
Countliste[x]:=strtoint(st);
end;
until st='';
finally
APA_Show_Process.Expertmode1.Checked:=false;
end;
end;
if APA_Show_Process.GroupBox1.tag=1 then begin
APA_Show_Process.GroupBox1.tag:=0;
neuespalte:=true;//Geheimticker
x:=lang+1;zahler:=0;
repeat;
if x>=0 then begin;
zahler:=zahler+1;
countliste[x]:=zahler;
end;
x:=x-1;
until x=-1;
end;
if APA_Show_Process.GroupBox1.tag=-1 then begin
APA_Show_Process.GroupBox1.tag:=0;
//Geheimticker
countliste[lang]:=0;
lang:=lang-1;
x:=lang;zahler:=0;
repeat;
if x>=0 then begin;
zahler:=zahler+1;
countliste[x]:=zahler;
end;
x:=x-1;
until x=-1;
- 368 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end;
until (neuespalte=true)or(stop=true)or(ende=true);
if (alwaysspacemaxreached=true) and(Alwaysspacemaxbeachten1.Checked=true) then
stop:=true;
//wenn die letzten z.B. 5 Cubes in allen Kombinationen zu wenig Speicherplatz
//hatten, gehen sich 6 Cubes auch nicht aus. Also Ende
lang:=lang+1;
until (ende=true)or(lang>=anzcube)or(stop=true);
//Speichern des aktuellen Cubeliste damit man wieder weiter machen kann.
//Speichern der aktuellen Position
assignfile(fCounter,'c:\APADIR\DATA\Counter.dat');
{$i-}
rewrite(fCounter);
{$i+}
if ioresult<>0 then showmessage('Can not open File Counter.dat');
try
seek(fCounter,0);
vCounter.Lfnr:=-1;
if vcounter.nr=1 then
if alwaysspacemaxreached=true then vcounter.Nr:=1
else vcounter.Nr:=0;
write(fCounter,vCounter);
for x:=0 to lang do begin
seek(fCounter,x+1);
vCounter.Lfnr:=x;
vCounter.Nr:=Countliste[x];
write(fCounter,vCounter);
end;
finally
CloseFile(fcounter);
end;
end;// Wenn es mindestens einen Cube gibt in der Cubeliste
end;//with Apa_Application
finally
closeFile(fkosten);
GeneriereReqListe.free;
Showmessage('Ready');
APA_Grid.Enabled:=true;
end;
end;
procedure TAPA_Grid.Options1Click(Sender: TObject);
begin
APA_Options.showmodal;
end;
procedure TAPA_Grid.ShowData1Click(Sender: TObject);
var st:string;
begin
st:='Screenbez: '+APA[zellespalte,zellezeile].screenbez;
st:=st+', Counthier:'+inttostr(APA[zellespalte,zellezeile].counthier)+', ';
st:=st+'Countdim: '+inttostr(APA[zellespalte,zellezeile].countdimension)+', ';
st:=st+'Weight: '+floattostr(APA[zellespalte,zellezeile].gewicht)+', ';
st:=st+'Weightlevel: '+inttostr(APA[zellespalte,zellezeile].gewichtlevel)+', ';
st:=st+'Matcount: '+inttostr(APA[zellespalte,zellezeile].matcount)+', ';
showmessage(st);
end;
procedure TAPA_Grid.Button5Click(Sender: TObject);
begin
Panel3.Width:=1;
end;
procedure TAPA_Grid.AlgorithmKombination1Click(Sender: TObject);
- 369 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
begin
if permutation=false then begin
Button4.click;
end else begin
APA_Dialog.APA_Text.Caption:='Your last deterministic run was a permutation. Do you
want do continue? This will delete your last run!';
if APA_Dialog.showmodal=mryes then begin;
Button4.Click;
end;
end;
end;
procedure TAPA_Grid.AlgorithmKombination2Click(Sender: TObject);
begin
Button4.Click;
end;
procedure TAPA_Grid.GetbuildBFT2Click(Sender: TObject);
begin
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');
{$i-}
reset(fKosten);
{$i+}
if ioresult<>0 then begin; showmessage('cost database error ');exit;end;
try
//Nur getbuild
showmessage(floattostr(getbuild(-1,-1,zellespalte,zellezeile)));
finally
CloseFile(fKosten);
end;
end;
procedure TAPA_Grid.GetbuildParent2Click(Sender: TObject);
var buildcosts, merkecosts:Extended;
var parentzeile,parentspalte:longint;
var zeile,spalte:longint;
begin
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');
{$i-}
reset(fKosten);
{$i+}
if ioresult<>0 then begin; showmessage('cost database error ');exit;end;
try
//Nur getbuild
merkecosts:=getbuild(-1,-1,zellespalte,zellezeile);;parentzeile:=-1;parentspalte:=-1;
for zeile:=0 to anzzeilen-1 do begin
for spalte:=0 to anzspalten-1 do begin
if APA[spalte,zeile].materalisieren=true then begin
if isderivat(spalte,zeile,zellespalte,zellezeile)=true then begin
buildcosts:=getbuild(spalte,zeile,zellespalte,zellezeile);
if (buildcosts<merkecosts) then begin
merkecosts:=buildcosts;
parentzeile:=zeile;
parentspalte:=spalte;
end;
end;
end;
end;//Ende spalten
end;//Ende zeilen
showmessage('Build from ('+inttostr(parentspalte)+':'+inttostr(parentzeile)+') costs:
'+floattostr(merkecosts));
finally
CloseFile(fKosten);
end;
end;
procedure TAPA_Grid.GetQueryBFT2Click(Sender: TObject);
begin
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');
- 370 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
{$i-}
reset(fKosten);
{$i+}
if ioresult<>0 then begin; showmessage('cost database error ');exit;end;
try
//Nur getquery
showmessage(floattostr(getquery(-1,-1,zellespalte,zellezeile)));
finally
CloseFile(fKosten);
end;
end;
procedure TAPA_Grid.GetQueryParent2Click(Sender: TObject);
var querycosts, merkecosts:Extended;
var parentzeile,parentspalte:longint;
var zeile,spalte:longint;
begin
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');
{$i-}
reset(fKosten);
{$i+}
if ioresult<>0 then begin; showmessage('cost database error ');exit;end;
try
//Nur getquery
merkecosts:=getquery(-1,-1,zellespalte,zellezeile);;
parentzeile:=-1;parentspalte:=-1;
for zeile:=0 to anzzeilen-1 do begin
for spalte:=0 to anzspalten-1 do begin
if APA[spalte,zeile].materalisieren=true then begin
if isderivat(spalte,zeile,zellespalte,zellezeile)=true then begin
querycosts:=getquery(spalte,zeile,zellespalte,zellezeile);
if (querycosts<merkecosts) then begin
merkecosts:=querycosts;
parentzeile:=zeile;
parentspalte:=spalte;
end;
end;
end;
end;//Ende spalten
end;//Ende zeilen
showmessage('Query from ('+inttostr(parentspalte)+':'+inttostr(parentzeile)+') costs:
'+floattostr(merkecosts));
finally
CloseFile(fKosten);
end;
end;
procedure TAPA_Grid.GenerateCREATESQLStatements1Click(Sender: TObject);
begin
GenerateCREATESQLStatementsBFTanddimensiontables3Click(self);
end;
procedure TAPA_Grid.SearchusingThomasAchsheuristic1Click(Sender: TObject);
begin
Button2.click;
end;
procedure TAPA_Grid.Panel1DblClick(Sender: TObject);
begin
Panel1.PopupMenu:=privatmenu;
end;
procedure TAPA_Grid.Buildrandomcosts1Click(Sender: TObject);
begin
APA_Application.GeneriereZufallskosten1Click(self);
end;
procedure TAPA_Grid.Showrandomcosts1Click(Sender: TObject);
begin
APA_Showcosts.showmodal;
end;
- 371 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
procedure TAPA_Grid.Showcosts2Click(Sender: TObject);
begin
Showcosts1Click(self);
end;
procedure TAPA_Grid.ShowAnalyseWindow1Click(Sender: TObject);
begin
Showlistbox1Click(self);
end;
procedure TAPA_Grid.AnalyseAPA1Click(Sender: TObject);
begin
APA_Application.AnalyseAPA1Click(self);
end;
procedure TAPA_Grid.ShowAnalysewindow2Click(Sender: TObject);
begin
APA_Application.AnalyseAPA1Click(self);
end;
procedure TAPA_Grid.Showpossiblecubes1Click(Sender: TObject);
var PossibleCubes:TStringList;
var counter,aktzeile,aktspalte,count_of_derivates:longint;
var zahler,derivspalte,derivzeile:longint;
begin
PossibleCubes:=TStringList.Create();
counter:=0;
for aktzeile:=0 to anzzeilen-1 do begin
for aktspalte:=0 to anzspalten-1 do begin
if (APA[aktspalte,aktzeile].interessant=true)and
(APA[aktspalte,aktzeile].farbe=clYellow) then begin//Auswählen des Würfels
PossibleCubes.Add(auffuellen(inttostr(aktspalte),10)+auffuellen(inttostr(aktzeile)
,10));
counter:=counter+1;
end;//of Auswählen des Würfels
end;//of aktspalte
end;//of aktzeile
{1.b Setze Derivate zu}
if tomohnederivate1.Checked=false then begin
for aktzeile:=0 to anzzeilen-1 do begin
for aktspalte:=0 to anzspalten-1 do begin
if
(APA[aktspalte,aktzeile].farbe=clYellow)and(APA[aktspalte,aktzeile].interessant=fa
lse) then begin
count_of_derivates:=0;
for derivspalte:=0 to anzspalten-1 do begin;
for derivzeile:=0 to anzzeilen-1 do begin;
if (APA[derivspalte,derivzeile].interessant=true)and
(APA[derivspalte,derivzeile].farbe=clYellow) then begin
if isderivat(aktspalte,aktzeile,derivspalte,derivzeile) then begin
//Jetzt kontrollieren wir, ob dieser Würfel auch noch ein Derivat eines
anderen Würfels
count_of_derivates:=count_of_derivates+1;
end;//Ende von derivat
end;//Ende von interessant
end;//of derivzeile
end;//of derivsspalte
if count_of_derivates>=1 then begin
PossibleCubes.Add(auffuellen(inttostr(aktspalte),10)+auffuellen(inttostr(aktzeile)
,10));
counter:=counter+1;
end;
end;//von Yellow
- 372 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end;//aktspalte
end;//aktzeile
end;
for zahler:=0 to PossibleCubes.count-1 do begin
APA[strtoint(copy(PossibleCubes[zahler],1,10)),strtoint(copy(PossibleCubes[zahler],11,10
))].flag:=1;
end;
APAGrid.Repaint;
showmessage('Found '+inttostr(counter)+' possible cubes. ');
Showpossiblecubes2.Visible:=false;
Removepossiblecubes2.Visible:=true;
end;
procedure TAPA_Grid.Removepossiblecubes1Click(Sender: TObject);
var aktzeile,aktspalte:longint;
begin
for aktzeile:=0 to anzzeilen-1 do begin
for aktspalte:=0 to anzspalten-1 do begin
APA[aktspalte,aktzeile].flag:=0;
end;
end;
APAGrid.Repaint;
Showpossiblecubes2.Visible:=true;
Removepossiblecubes2.Visible:=false;
end;
procedure TAPA_Grid.Showpossiblecubes2Click(Sender: TObject);
begin
Showpossiblecubes1Click(self);
end;
procedure TAPA_Grid.Removepossiblecubes2Click(Sender: TObject);
begin
Removepossiblecubes1Click(self);
end;
procedure TAPA_Grid.Getmaterialisationspaceofcube1Click(Sender: TObject);
begin
showmessage('Space required:
'+floattostr((strtofloat(APA_Parameter.APA_Thomas_avsizeoftupel.text)*gettupel(zel
lespalte,zellezeile))));
end;
procedure TAPA_Grid.ShowButtons1Click(Sender: TObject);
begin
Button1.Visible:=true;
Button2.Visible:=true;
Button3.Visible:=true;
Button4.Visible:=true;
end;
procedure TAPA_Grid.GetbuildBFT1Click(Sender: TObject);
begin
//Nur delta
showmessage('The Materialisation costs are
'+floattostr(deltaBFTW(zellespalte,zellezeile,false)));
end;
procedure TAPA_Grid.GetqueryfromBFT1Click(Sender: TObject);
begin
//Nur delta
showmessage('The Query costs are '+floattostr(deltaBFTW(zellespalte,zellezeile,true)));
end;
- 373 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
procedure TAPA_Grid.Getbuildfromparent1Click(Sender: TObject);
var buildcosts, merkecosts:Extended;
var parentzeile,parentspalte:longint;
var zeile,spalte:longint;
begin
//Nur delta
merkecosts:=deltaBFTW(zellespalte,zellezeile,false);parentzeile:=-1;parentspalte:=-1;
for zeile:=0 to anzzeilen-1 do begin
for spalte:=0 to anzspalten-1 do begin
if APA[spalte,zeile].materalisieren=true then begin
if isderivat(spalte,zeile,zellespalte,zellezeile)=true then begin
buildcosts:=deltaVW(spalte,zeile,zellespalte,zellezeile,false);
if (buildcosts<merkecosts) then begin
merkecosts:=buildcosts;
parentzeile:=zeile;
parentspalte:=spalte;
end;
end;
end;
end;//Ende spalten
end;//Ende zeilen
showmessage('Build from ('+inttostr(parentspalte)+':'+inttostr(parentzeile)+') costs:
'+floattostr(merkecosts));
end;
procedure TAPA_Grid.Getqueryfromparent1Click(Sender: TObject);
var querycosts, merkecosts:Extended;
var parentzeile,parentspalte:longint;
var zeile,spalte:longint;
begin
//Nur delta
merkecosts:=deltaBFTW(zellespalte,zellezeile,true);;
parentzeile:=-1;parentspalte:=-1;
for zeile:=0 to anzzeilen-1 do begin
for spalte:=0 to anzspalten-1 do begin
if APA[spalte,zeile].materalisieren=true then begin
if isderivat(spalte,zeile,zellespalte,zellezeile)=true then begin
querycosts:=deltaVW(spalte,zeile,zellespalte,zellezeile,true);
if (querycosts<merkecosts) then begin
merkecosts:=querycosts;
parentzeile:=zeile;
parentspalte:=spalte;
end;
end;
end;
end;//Ende spalten
end;//Ende zeilen
showmessage('Query from ('+inttostr(parentspalte)+':'+inttostr(parentzeile)+') costs:
'+floattostr(merkecosts));
end;
procedure TAPA_Grid.ShowSetcalculatedcostsandlimitsleft1Click(
Sender: TObject);
var zeile,spalte, zahler:longint;
var MatCubes,ReqCubes, MatCubesSorted:TStringList;
var merkerandom:boolean;
begin
//Berechne die Kosten der aktuellen Materialsierung
//auf der Basis der Zufallskosten
if matcount>0 then begin
Listbox1.Items.Add('');
Listbox1.Items.Add('Berechne Kosten');
Listbox1.Items.Add('');
ReqCubes:=TStringList.Create;
ReqCubes.Clear;
- 374 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
MatCubes:=TStringList.Create;
MatCubes.Clear;
MatCubesSorted:=TStringList.Create;
MatCubesSorted.Clear;
merkerandom:=Userandomcosts1.Checked;
Userandomcosts1.Checked:=false;
try
//Lege alle nicht redundaten Cubes an, und vergib eine Nummer
for zeile:=0 to anzzeilen-1 do begin
for spalte:=0 to anzspalten-1 do begin
if APA[spalte,zeile].farbe=clYellow then begin
if APA[spalte,zeile].interessant=true then begin
//Speichere Required Cubes
//Merke dir die Required Cubes
ReqCubes.Add(auffuellen(inttostr(spalte),10)+auffuellen(inttostr(zeile),10));
end;
if APA[spalte,zeile].materalisieren=true then begin
//Speichere Mat Cubes
//Merke dir die MatCubes
MatCubes.Add(auffuellen(inttostr(spalte),10)+auffuellen(inttostr(zeile),10));;
end;
end;
end;//end of spalte
end;//end of zeilen
for zahler:=0 to MatCubes.count-1 do MatCubesSorted.Add('free');
for zahler:=0 to MatCubes.Count-1 do begin
MatCubesSorted[APA[strtoint(copy(MatCubes[zahler],1,10)),strtoint(copy(MatCubes[zahler],
11,10))].matcount-1]:=
MatCubes[zahler];
end;
showmessage('Costs: '+floattostr(berechneKostenGesamt(MatCubesSorted,ReqCubes,false))+';
Time left: '+
floattostr(timeleft)+'; Space left: '+floattostr(spaceleft));
finally
MatCubes.Free;
ReqCubes.Free;
MatCubesSorted.Free;
Userandomcosts1.Checked:=merkerandom;
end;
end //of matcount
else showmessage('No materialized cubes selected');
end;
procedure TAPA_Grid.Restrictedcosts1Click(Sender: TObject);
begin
APA_Application.Restrictedcosts1.Checked:=APA_Grid.Restrictedcosts1.Checked;
end;
procedure TAPA_Grid.Showdeterministicsolution2Click(Sender: TObject);
begin
Showdeterministicsolution1Click(self);
end;
procedure TAPA_Grid.Showdeterministicsolution1Click(Sender: TObject);
var countcube,pos:longint;
var SolutionList:TStringList;
begin
- 375 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
assignfile(fCountermerk,'c:\APADIR\DATA\Countermerk.dat');
{$i-}
reset(fCountermerk);
{$i+}
if ioresult<>0 then showmessage('Can not open File Countermerk.dat');
try
if filesize(fCountermerk)>0 then begin
SolutionList:=TStringList.Create();
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');
{$i-}
reset(fKosten);
{$i+}
if ioresult<>0 then begin; showmessage('cost database error ');exit;end;
assignfile(fCubes,'C:\APADIR\DATA\Cubes.dat');
{$i-}
reset(fCubes);
{$i+}
if ioresult<>0 then showmessage('Can not open File Cubes.dat');
try
pos:=0;
repeat;
if filesize(fcountermerk)>0 then begin
seek(fCountermerk,pos);
read(fCountermerk,vCountermerk);
seek(fCubes,round(vCountermerk.nr)-1);
read(fCubes,vCubes);
SolutionList.Add(auffuellen(inttostr(vCubes.Spalte),10)+auffuellen(inttostr(vCubes
.Zeile),10));
end;
pos:=pos+1;
until pos=filesize(fCountermerk);
SolutionList:=GetRightOrdertom(SolutionList);
for countcube:=0 to SolutionList.Count-1 do begin
APA[strtoint(copy(SolutionList[countcube],1,10)),strtoint(copy(SolutionList[countc
ube],11,10))].flag:=(2+((countcube+1)/10000))
end;
Showdeterministicsolution2.Visible:=false;
Removedeterministicsolution2.Visible:=true;
APAGrid.Repaint;
finally
CloseFile(fKosten);
CloseFile(fCubes);
SolutionList.Free;
end;
end else showmessage('No solution found');
finally
CloseFile(fCountermerk);
end;
end;
procedure TAPA_Grid.Removedeterministicsolution1Click(Sender: TObject);
var zeile,spalte:longint;
begin
for spalte:=0 to anzspalten-1 do begin
for zeile:=0 to anzzeilen-1 do begin
if (APA[spalte,zeile].flag>=2)and(APA[spalte,zeile].flag<3) then begin
APA[spalte,zeile].flag:=0;
end;
- 376 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end;
end;
Showdeterministicsolution2.Visible:=true;
Removedeterministicsolution2.Visible:=false;
APAGrid.Repaint;
end;
procedure TAPA_Grid.Removedeterministicsolution2Click(Sender: TObject);
begin
Removedeterministicsolution1Click(self);
end;
procedure TAPA_Grid.GenerateCREATESQLStatementsBFTanddimensiontables3Click(
Sender: TObject);
var counter, counter2:longint;
var Fieldnamemerk ,Fieldtypemerk:string;
begin
//Generiere BFT Table und Dimension Tables
APA_Sql.Sqltext.lines.Clear;
//1. Generiere Dimension Tables
for counter:=0 to anzd-1 do begin//Counter für Dimensionen
APA_Sql.Sqltext.lines.add('if exists (select * from dbo.sysobjects where id =
object_id(N''[dbo].[FK_BFT_'+dimbez[counter]+'_table]'')');
APA_Sql.Sqltext.lines.add('
and OBJECTPROPERTY(id, N''IsForeignKey'') = 1)');
APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].[BFT] DROP CONSTRAINT
FK_BFT_'+dimbez[counter]+'_table');
APA_Sql.Sqltext.lines.add('GO');
APA_Sql.Sqltext.lines.add('');
APA_Sql.Sqltext.lines.add('if exists (select * from dbo.sysobjects where id =
object_id(N''[dbo].['+dimbez[counter]+'_table]'') and OBJECTPROPERTY(id,
N''IsUserTable'') = 1)');
APA_Sql.Sqltext.lines.add('drop table [dbo].['+dimbez[counter]+'_table]');
APA_Sql.Sqltext.lines.add('GO');
APA_Sql.Sqltext.lines.add('');
APA_Sql.Sqltext.lines.add('CREATE TABLE [dbo].['+dimbez[counter]+'_table] (');
APA_Sql.Sqltext.lines.add('
['+dimbez[counter]+'_id] [varchar] (50) COLLATE
Latin1_General_CI_AS NOT NULL ,');
for counter2:=0 to anzh[counter]-1 do begin//Counter für Hierarchiestufen
APA_Sql.Sqltext.lines.add('
['+dk[counter,counter2]+'] [varchar] (12) COLLATE
Latin1_General_CI_AS NOT NULL ,');
APA_Sql.Sqltext.lines.add('
['+dk[counter,counter2]+'_desc] [varchar] (40) COLLATE
Latin1_General_CI_AS NOT NULL ,');
end;//Counter für Hierarchiestufen
APA_Sql.Sqltext.lines.add('
[level] [bigint] NOT NULL');
APA_Sql.Sqltext.lines.add(') ON [PRIMARY]');
APA_Sql.Sqltext.lines.add('GO');
APA_Sql.Sqltext.lines.add('');
APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].['+dimbez[counter]+'_table] WITH NOCHECK
ADD');
APA_Sql.Sqltext.lines.add('
CONSTRAINT [PK_'+dimbez[counter]+'_table] PRIMARY KEY
CLUSTERED');
APA_Sql.Sqltext.lines.add('
(');
APA_Sql.Sqltext.lines.add('
['+dimbez[counter]+'_id]');
APA_Sql.Sqltext.lines.add('
) ON [PRIMARY]');
APA_Sql.Sqltext.lines.add('GO');
APA_Sql.Sqltext.lines.add('');
end;//Counter für Dimensionen Ende
//2. Generiere BFT Table
APA_Sql.Sqltext.lines.add('if exists (select * from dbo.sysobjects where id =
object_id(N''[dbo].[BFT]'')');
APA_Sql.Sqltext.lines.add('and OBJECTPROPERTY(id, N''IsUserTable'') = 1)');
APA_Sql.Sqltext.lines.add('drop table [dbo].[BFT]');
APA_Sql.Sqltext.lines.add('GO');
APA_Sql.Sqltext.lines.add('');
APA_Sql.Sqltext.lines.add('CREATE TABLE [dbo].[BFT] (');
for counter:=0 to anzd-1 do begin
- 377 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
APA_Sql.Sqltext.lines.add('
['+dimbez[counter]+'_id] [varchar] (50) COLLATE
Latin1_General_CI_AS NOT NULL ,');
end;
for counter:=0 to APA_Input_Screen.Keybox.Items.Count-1 do begin
Fieldnamemerk:=
copy(APA_Input_Screen.Keybox.items[counter],1,pos('//',APA_Input_Screen.Keybox.ite
ms[counter])-1);
Fieldtypemerk:=
APA_Insert_Key.APA_Field_type.Items[APA_Insert_Key.APA_Field_type.Items.IndexOf(co
py(APA_Input_Screen.Keybox.items[counter],pos('//',APA_Input_Screen.Keybox.items[c
ounter])+6,
length(APA_Input_Screen.Keybox.items[counter])(pos('//',APA_Input_Screen.Keybox.items[counter])+6)))];
APA_Sql.Sqltext.lines.add('
end;
['+Fieldnamemerk+'] ['+Fieldtypemerk+'] NOT NULL ,');
//Beistrich entfernen
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);
APA_Sql.Sqltext.lines.add(') ON [PRIMARY]');
APA_Sql.Sqltext.lines.add('GO');
APA_Sql.Sqltext.lines.add('');
APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].[BFT] WITH NOCHECK ADD');
APA_Sql.Sqltext.lines.add('
CONSTRAINT [PK_BFT] PRIMARY KEY CLUSTERED');
APA_Sql.Sqltext.lines.add('
(');
for counter:=0 to anzd-1 do begin
APA_Sql.Sqltext.lines.add('
['+dimbez[counter]+'_id],');
end;
//Beistrich entfernen
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);
APA_Sql.Sqltext.lines.add('
) ON [PRIMARY]');
APA_Sql.Sqltext.lines.add('GO');
APA_Sql.Sqltext.lines.add('');
//3. Zusetzen der FK Schlüssel
for counter:=0 to anzd-1 do begin
APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].[BFT] ADD');
APA_Sql.Sqltext.lines.add('
CONSTRAINT [FK_BFT_'+dimbez[counter]+'_table] FOREIGN
KEY');
APA_Sql.Sqltext.lines.add('
(');
APA_Sql.Sqltext.lines.add('
['+dimbez[counter]+'_id]');
APA_Sql.Sqltext.lines.add('
) REFERENCES [dbo].['+dimbez[counter]+'_table] (');
APA_Sql.Sqltext.lines.add('
['+dimbez[counter]+'_id]');
APA_Sql.Sqltext.lines.add('
) ON UPDATE CASCADE ');
APA_Sql.Sqltext.lines.add('');
APA_Sql.Sqltext.lines.add('GO');
APA_Sql.Sqltext.lines.add('');
end; //of counter
APA_Sql.Show;
end;
procedure TAPA_Grid.GenerateCREATESQLStatementsformaterializedcubes2Click(
Sender: TObject);
var spalte,zeile,zahler:longint;
var tablename:string;
var counter:longint;
var Fieldnamemerk ,Fieldtypemerk:string;
var foundcube:boolean;
begin
- 378 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
{1. Für alle materialisierten Würfel}
APA_Sql.Sqltext.lines.Clear;
foundcube:=false;
for spalte:=0 to anzspalten-1 do begin
for zeile:=0 to anzzeilen-1 do begin
if APA[spalte,zeile].materalisieren=true then begin
tablename:='';foundcube:=true;
for zahler:=0 to anzd-1 do begin
tablename:=tablename+dk[zahler,APA[spalte,zeile].hierstufe[zahler]];
end;
APA_Sql.Sqltext.lines.add('');
APA_Sql.Sqltext.lines.add('if exists (select * from dbo.sysobjects where ');
APA_Sql.Sqltext.lines.add('id = object_id(N''[dbo].[FT '+tablename+']'') and
OBJECTPROPERTY(id, N''IsUserTable'') = 1)');
APA_Sql.Sqltext.lines.add('drop table [dbo].[FT '+tablename+']');
APA_Sql.Sqltext.lines.add('GO');
APA_Sql.Sqltext.lines.add('');
APA_Sql.Sqltext.lines.add('CREATE TABLE [dbo].[FT '+tablename+'] ( ');
for zahler:=0 to anzd-1 do begin
if (anzh[zahler]-1<>APA[spalte,zeile].hierstufe[zahler]) then
APA_Sql.Sqltext.lines.add('
['+dk[zahler,APA[spalte,zeile].hierstufe[zahler]]+']
[varchar] (12) COLLATE Latin1_General_CI_AS NOT NULL ,');
end;
for counter:=0 to APA_Input_Screen.Keybox.Items.Count-1 do begin
Fieldnamemerk:=
copy(APA_Input_Screen.Keybox.items[counter],1,pos('//',APA_Input_Screen.Keybox.ite
ms[counter])-1);
Fieldtypemerk:=
APA_Insert_Key.APA_Field_type.Items[APA_Insert_Key.APA_Field_type.Items.IndexOf(co
py(APA_Input_Screen.Keybox.items[counter],pos('//',APA_Input_Screen.Keybox.items[c
ounter])+6,
length(APA_Input_Screen.Keybox.items[counter])(pos('//',APA_Input_Screen.Keybox.items[counter])+6)))];
APA_Sql.Sqltext.lines.add('
end;
['+Fieldnamemerk+'] ['+Fieldtypemerk+'] NOT NULL ,');
//Beistrich entfernen
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);
APA_Sql.Sqltext.lines.add(') ON [PRIMARY]');
APA_Sql.Sqltext.lines.add('GO');
APA_Sql.Sqltext.lines.add('');
APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].[FT '+tablename+'] WITH NOCHECK ADD');
APA_Sql.Sqltext.lines.add('
CONSTRAINT [PK_FT '+tablename+'] PRIMARY KEY CLUSTERED');
APA_Sql.Sqltext.lines.add('
( ');
for zahler:=0 to anzd-1 do begin
if (anzh[zahler]-1<>APA[spalte,zeile].hierstufe[zahler]) then
APA_Sql.Sqltext.lines.add('
['+dk[zahler,APA[spalte,zeile].hierstufe[zahler]]+'] ,');
end;
//Beistrich entfernen
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);
APA_Sql.Sqltext.lines.add('
) ON [PRIMARY]');
APA_Sql.Sqltext.lines.add('GO');
APA_Sql.Sqltext.lines.add('');
end; //End Materialisieren
end;// End Zeile
end;//End Spalte
if foundcube=true then
APA_Sql.Show
- 379 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
else
showmessage('No materialized cube found!');
end;
procedure TAPA_Grid.GenerateCREATESQLStatementsBFTanddimensiontables2Click(
Sender: TObject);
var counter, counter2:longint;
var Fieldnamemerk ,Fieldtypemerk:string;
begin
//Generiere BFT Table und Dimension Tables
APA_Sql.Sqltext.lines.Clear;
//1. Generiere Dimension Tables
for counter:=0 to anzd-1 do begin//Counter für Dimensionen
APA_Sql.Sqltext.lines.add('if exists (select * from dbo.sysobjects where id =
object_id(N''[dbo].[FK_BFT_'+dimbez[counter]+'_table]'')');
APA_Sql.Sqltext.lines.add('
and OBJECTPROPERTY(id, N''IsForeignKey'') = 1)');
APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].[BFT] DROP CONSTRAINT
FK_BFT_'+dimbez[counter]+'_table');
APA_Sql.Sqltext.lines.add('GO');
APA_Sql.Sqltext.lines.add('');
APA_Sql.Sqltext.lines.add('if exists (select * from dbo.sysobjects where id =
object_id(N''[dbo].['+dimbez[counter]+'_table]'') and OBJECTPROPERTY(id,
N''IsUserTable'') = 1)');
APA_Sql.Sqltext.lines.add('drop table [dbo].['+dimbez[counter]+'_table]');
APA_Sql.Sqltext.lines.add('GO');
APA_Sql.Sqltext.lines.add('');
APA_Sql.Sqltext.lines.add('CREATE TABLE [dbo].['+dimbez[counter]+'_table] (');
//Primärschlüssel
APA_Sql.Sqltext.lines.add('
['+dimbez[counter]+'_id] [varchar] (50) COLLATE
Latin1_General_CI_AS NOT NULL ,');
for counter2:=0 to anzh[counter]-1 do begin//Counter für Hierarchiestufen
APA_Sql.Sqltext.lines.add('
['+dk[counter,counter2]+'] [varchar] (12) COLLATE
Latin1_General_CI_AS NOT NULL ,');
APA_Sql.Sqltext.lines.add('
['+dk[counter,counter2]+'_desc] [varchar] (40) COLLATE
Latin1_General_CI_AS NOT NULL ,');
end;//Counter für Hierarchiestufen
APA_Sql.Sqltext.lines.add(') ON [PRIMARY]');
APA_Sql.Sqltext.lines.add('GO');
APA_Sql.Sqltext.lines.add('');
APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].['+dimbez[counter]+'_table] WITH NOCHECK
ADD');
APA_Sql.Sqltext.lines.add('
CONSTRAINT [PK_'+dimbez[counter]+'_table] PRIMARY KEY
CLUSTERED');
APA_Sql.Sqltext.lines.add('
(');
APA_Sql.Sqltext.lines.add('
['+dimbez[counter]+'_id]');
APA_Sql.Sqltext.lines.add('
) ON [PRIMARY]');
APA_Sql.Sqltext.lines.add('GO');
APA_Sql.Sqltext.lines.add('');
for counter2:=0 to anzh[counter]-1 do begin
APA_Sql.Sqltext.lines.add(' CREATE INDEX [IX_'+dk[counter,counter2]+'] ON
[dbo].['+dimbez[counter]+'_table](['+dk[counter,counter2]+']) ON [PRIMARY]');
APA_Sql.Sqltext.lines.add('GO');
APA_Sql.Sqltext.lines.add('');
end;
end;//Counter für Dimensionen Ende
//2. Generiere BFT Table
APA_Sql.Sqltext.lines.add('if exists (select * from dbo.sysobjects where id =
object_id(N''[dbo].[BFT]'')');
APA_Sql.Sqltext.lines.add('and OBJECTPROPERTY(id, N''IsUserTable'') = 1)');
APA_Sql.Sqltext.lines.add('drop table [dbo].[BFT]');
- 380 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
APA_Sql.Sqltext.lines.add('GO');
APA_Sql.Sqltext.lines.add('');
APA_Sql.Sqltext.lines.add('CREATE TABLE [dbo].[BFT] (');
for counter:=0 to anzd-1 do begin
APA_Sql.Sqltext.lines.add('
['+dimbez[counter]+'_id] [varchar] (50) COLLATE
Latin1_General_CI_AS NOT NULL ,');
end;
for counter:=0 to APA_Input_Screen.Keybox.Items.Count-1 do begin
Fieldnamemerk:=
copy(APA_Input_Screen.Keybox.items[counter],1,pos('//',APA_Input_Screen.Keybox.ite
ms[counter])-1);
Fieldtypemerk:=
APA_Insert_Key.APA_Field_type.Items[APA_Insert_Key.APA_Field_type.Items.IndexOf(co
py(APA_Input_Screen.Keybox.items[counter],pos('//',APA_Input_Screen.Keybox.items[c
ounter])+6,
length(APA_Input_Screen.Keybox.items[counter])(pos('//',APA_Input_Screen.Keybox.items[counter])+6)))];
APA_Sql.Sqltext.lines.add('
end;
['+Fieldnamemerk+'] ['+Fieldtypemerk+'] NOT NULL ,');
//Beistrich entfernen
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);
APA_Sql.Sqltext.lines.add(') ON [PRIMARY]');
APA_Sql.Sqltext.lines.add('GO');
APA_Sql.Sqltext.lines.add('');
APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].[BFT] WITH NOCHECK ADD');
APA_Sql.Sqltext.lines.add('
CONSTRAINT [PK_BFT] PRIMARY KEY CLUSTERED');
APA_Sql.Sqltext.lines.add('
(');
for counter:=0 to anzd-1 do begin
APA_Sql.Sqltext.lines.add('
['+dimbez[counter]+'_id],');
end;
//Beistrich entfernen
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);
APA_Sql.Sqltext.lines.add('
) ON [PRIMARY]');
APA_Sql.Sqltext.lines.add('GO');
APA_Sql.Sqltext.lines.add('');
//3. Zusetzen der FK Schlüssel
for counter:=0 to anzd-1 do begin
APA_Sql.Sqltext.lines.add('ALTER TABLE [dbo].[BFT] ADD');
APA_Sql.Sqltext.lines.add('
CONSTRAINT [FK_BFT_'+dimbez[counter]+'_table] FOREIGN
KEY');
APA_Sql.Sqltext.lines.add('
(');
APA_Sql.Sqltext.lines.add('
['+dimbez[counter]+'_id]');
APA_Sql.Sqltext.lines.add('
) REFERENCES [dbo].['+dimbez[counter]+'_table] (');
APA_Sql.Sqltext.lines.add('
['+dimbez[counter]+'_id]');
APA_Sql.Sqltext.lines.add('
) ON UPDATE CASCADE ');
APA_Sql.Sqltext.lines.add('');
APA_Sql.Sqltext.lines.add('GO');
APA_Sql.Sqltext.lines.add('');
end; //of counter
APA_Sql.Show;
end;
procedure TAPA_Grid.GenerateCREATESQLStatementsBFTanddimensiontables1Click(
Sender: TObject);
begin
GenerateCREATESQLStatementsBFTanddimensiontables2Click(self);
- 381 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end;
procedure TAPA_Grid.GenerateCREATESQLStatementsformaterializedcubes1Click(
Sender: TObject);
begin
GenerateCREATESQLStatementsformaterializedcubes2Click(self);
end;
procedure TAPA_Grid.APAGridMouseWheelUp(Sender: TObject;
Shift: TShiftState; MousePos: TPoint; var Handled: Boolean);
begin
zellespalte:=-1;
zellezeile:=-1;
end;
procedure TAPA_Grid.HelpforAPAGridScreen1Click(Sender: TObject);
begin
APA_Help.show;
APA_Help.APABrowser.Navigate('C:\APADIR\Help\APA_Grid.htm');
end;
procedure TAPA_Grid.HelpforAPAProgram1Click(Sender: TObject);
begin
APA_Help.show;
APA_Help.APABrowser.Navigate('C:\APADIR\Help\index.htm');
end;
procedure TAPA_Grid.factconstellationschema1Click(Sender: TObject);
var aktspalte,aktzeile,parentzeile,parentspalte, counter:longint;
var merkcosts, bestmerkcosts:Extended;
var sumdimension:array of longint;
var tablename:string;
var nix, gleich:boolean;
begin
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');
{$i-}
reset(fKosten);
{$i+}
if ioresult<>0 then begin; showmessage('cost database error ');exit;end;
try
{1. Finden den Cube oder den BFT aus welchem abgefragt wird}
parentzeile:=-1;parentspalte:=-1;// Kann immer aus dem BFT abgeleitet werden
if (Userandomcosts1.Checked=true) then begin
bestmerkcosts:=getquery(-1,-1,zellespalte,zellezeile);
end else begin
bestmerkcosts:=deltaBftW(zellespalte,zellezeile,true);
end;
for aktzeile:=0 to anzzeilen-1 do begin
for aktspalte:=0 to anzspalten-1 do begin
if APA[aktspalte,aktzeile].materalisieren=true then begin
if isderivat(aktspalte,aktzeile,zellespalte,zellezeile)=true then begin
if (Userandomcosts1.Checked=true) then begin
merkcosts:=getquery(aktspalte,aktzeile,zellespalte,zellezeile);
end else begin
merkcosts:=deltaVW(aktspalte,aktzeile,zellespalte,zellezeile,true);
end;
if merkcosts<bestmerkcosts then begin
parentzeile:=aktzeile;parentspalte:=aktspalte;
bestmerkcosts:=merkcosts;
end; //merkcosts<bestmerkcosts
end; //isderivat
end; //materialisiert
end;//aktspalte
end;//altzeile
{2. Erzeuge die SQL Statements}
- 382 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
{2.1. Finde die Dimensionen welche aggregiert werden müssen}
sumdimension:=nil;
setlength(sumdimension,anzd);
for counter:=0 to anzd-1 do sumdimension[counter]:=-1;
for counter:=0 to anzd-1 do begin
if (APA[zellespalte,zellezeile].hierstufe[counter]<>anzh[counter]-1) then begin
sumdimension[counter]:=APA[zellespalte,zellezeile].hierstufe[counter];
end;
end;
APA_Sql.Sqltext.lines.Clear;
if parentspalte=-1 then begin
APA_Sql.Sqltext.lines.add('SELECT ');
for counter:=0 to anzd-1 do begin
if sumdimension[counter]<>-1 then begin
//Feld aus dem Dimension table
APA_Sql.Sqltext.lines.add('
dbo.['+dimbez[counter]+'_table].['+dk[counter,APA[zellespalte,zellezeile].hierstuf
e[counter]]+'],');
end;
end;
for counter:=0 to APA_Input_Screen.Keybox.Items.Count-1 do begin
APA_Sql.Sqltext.lines.add(copy(APA_Input_Screen.Keybox.items[counter],pos('//',APA
_Input_Screen.Keybox.items[counter])+2,3)+'(['+
copy(APA_Input_Screen.Keybox.items[counter],1,pos('//',APA_Input_Screen.Keybox.ite
ms[counter])-1)+'])'+
' AS
['+copy(APA_Input_Screen.Keybox.items[counter],1,pos('//',APA_Input_Screen.Keybox.
items[counter])-1)+'],');
end;
//Beistrich entfernen
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);
APA_Sql.Sqltext.lines.add('FROM dbo.BFT');
for counter:=0 to anzd-1 do begin
if sumdimension[counter]<>-1 then begin
//Feld aus dem Dimension table
APA_Sql.Sqltext.lines.add(' INNER JOIN dbo.['+dimbez[counter]+'_table] ON
dbo.BFT.['+dimbez[counter]+'_id]=');
APA_Sql.Sqltext.lines.add('
dbo.['+dimbez[counter]+'_table].['+dimbez[counter]+'_id]');
end;
end;
APA_Sql.Sqltext.lines.add('GROUP BY ');
for counter:=0 to anzd-1 do begin
if sumdimension[counter]<>-1 then begin
//Feld aus dem Dimension table
APA_Sql.Sqltext.lines.add('
dbo.['+dimbez[counter]+'_table].['+dk[counter,APA[zellespalte,zellezeile].hierstuf
e[counter]]+'],');
end;
end;
//Beistrich entfernen
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);
end else begin
//Abfrage aus dem aggregierten Cube
- 383 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
tablename:='';nix:=true;
for counter:=0 to anzd-1 do begin
tablename:=tablename+dk[counter,APA[parentspalte,parentzeile].hierstufe[counter]];
end;
gleich:=true;
for counter:=0 to anzd-1 do begin
if (APA[zellespalte,zellezeile].hierstufe[counter]>
APA[parentspalte,parentzeile].hierstufe[counter])
and(APA[zellespalte,zellezeile].hierstufe[counter]<>anzh[counter]-1) then begin
sumdimension[counter]:=APA[zellespalte,zellezeile].hierstufe[counter];
end;
if
(APA[zellespalte,zellezeile].hierstufe[counter]<>APA[parentspalte,parentzeile].hie
rstufe[counter])
then gleich:=false;
end;
APA_Sql.Sqltext.lines.add('SELECT ');
if gleich=false then begin
for counter:=0 to anzd-1 do begin
if sumdimension[counter]<>-1 then begin
//Feld aus dem Dimension table
if (anzh[counter]-1<>APA[zellespalte,zellezeile].hierstufe[counter]) then
begin;
APA_Sql.Sqltext.lines.add('
dbo.['+dimbez[counter]+'_table].['+dk[counter,APA[zellespalte,zellezeile].hierstuf
e[counter]]+'],');
nix:=false;
end;
end else begin
//Feld aus dem Abfrage Table
if (anzh[counter]-1<>APA[zellespalte,zellezeile].hierstufe[counter]) then
begin;
APA_Sql.Sqltext.lines.add('
dbo.['+tablename+'].['+dk[counter,APA[zellespalte,zellezeile].hierstufe[counter]]+
'],');
nix:=false;
end;
end;
end;
for counter:=0 to APA_Input_Screen.Keybox.Items.Count-1 do begin
APA_Sql.Sqltext.lines.add(copy(APA_Input_Screen.Keybox.items[counter],pos('//',APA
_Input_Screen.Keybox.items[counter])+2,3)+'(['+
copy(APA_Input_Screen.Keybox.items[counter],1,pos('//',APA_Input_Screen.Keybox.ite
ms[counter])-1)+'])'+
' AS
['+copy(APA_Input_Screen.Keybox.items[counter],1,pos('//',APA_Input_Screen.Keybox.
items[counter])-1)+'],');
end;
//Beistrich entfernen
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);
end // von gleich
else
APA_Sql.Sqltext.lines.add('*');
APA_Sql.Sqltext.lines.add('FROM dbo.['+tablename+']');
if gleich=false then begin
for counter:=0 to anzd-1 do begin
if sumdimension[counter]<>-1 then begin
//Feld aus dem Dimension table
if (anzh[counter]-1<>APA[zellespalte,zellezeile].hierstufe[counter]) then
begin
APA_Sql.Sqltext.lines.add(' INNER JOIN dbo.['+dimbez[counter]+'_table] ON
dbo.['+tablename+'].['+dk[counter,APA[parentspalte,parentzeile].hierstufe[counter]
]+']=');
- 384 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
APA_Sql.Sqltext.lines.add('
dbo.['+dimbez[counter]+'_table].['+dk[counter,APA[parentspalte,parentzeile].hierst
ufe[counter]]+']');
end;
end;
end;
if nix=false then
APA_Sql.Sqltext.lines.add('GROUP BY ');
for counter:=0 to anzd-1 do begin
if sumdimension[counter]<>-1 then begin
//Feld aus dem Dimension table
if (anzh[counter]-1<>APA[zellespalte,zellezeile].hierstufe[counter]) then
APA_Sql.Sqltext.lines.add('
dbo.['+dimbez[counter]+'_table].['+dk[counter,APA[zellespalte,zellezeile].hierstuf
e[counter]]+'],');
end else begin
//Feld aus dem BFT Table
if (anzh[counter]-1<>APA[zellespalte,zellezeile].hierstufe[counter]) then
APA_Sql.Sqltext.lines.add('
dbo.['+tablename+'].['+dk[counter,APA[zellespalte,zellezeile].hierstufe[counter]]+
'],');
end;
end;
//Beistrich entfernen
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);
end; // von gleich
end;
finally
CloseFile(fKosten);
end;
APA_Sql.Show;
end;
procedure TAPA_Grid.starschema1Click(Sender: TObject);
var aktspalte,aktzeile,parentzeile,parentspalte, counter:longint;
var merkcosts, bestmerkcosts:Extended;
var sumdimension:array of longint;
begin
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');
{$i-}
reset(fKosten);
{$i+}
if ioresult<>0 then begin; showmessage('cost database error ');exit;end;
try
{1. Finden den Cube oder den BFT aus welchem abgefragt wird}
parentzeile:=-1;parentspalte:=-1;// Kann immer aus dem BFT abgeleitet werden
if (Userandomcosts1.Checked=true) then begin
bestmerkcosts:=getquery(-1,-1,zellespalte,zellezeile);
end else begin
bestmerkcosts:=deltaBftW(zellespalte,zellezeile,true);
end;
for aktzeile:=0 to anzzeilen-1 do begin
for aktspalte:=0 to anzspalten-1 do begin
if APA[aktspalte,aktzeile].materalisieren=true then begin
if isderivat(aktspalte,aktzeile,zellespalte,zellezeile)=true then begin
if (Userandomcosts1.Checked=true) then begin
merkcosts:=getquery(aktspalte,aktzeile,zellespalte,zellezeile);
end else begin
merkcosts:=deltaVW(aktspalte,aktzeile,zellespalte,zellezeile,true);
end;
- 385 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if merkcosts<bestmerkcosts then begin
parentzeile:=aktzeile;parentspalte:=aktspalte;
bestmerkcosts:=merkcosts;
end; //merkcosts<bestmerkcosts
end; //isderivat
end; //materialisiert
end;//aktspalte
end;//altzeile
{2. Erzeuge die SQL Statements}
{2.1. Finde die Dimensionen welche aggregiert werden müssen}
sumdimension:=nil;
setlength(sumdimension,anzd);
for counter:=0 to anzd-1 do sumdimension[counter]:=-1;
for counter:=0 to anzd-1 do begin
if (APA[zellespalte,zellezeile].hierstufe[counter]<>anzh[counter]-1) then begin
sumdimension[counter]:=APA[zellespalte,zellezeile].hierstufe[counter];
end;
end;
APA_Sql.Sqltext.lines.Clear;
if parentspalte=-1 then begin
APA_Sql.Sqltext.lines.add('SELECT ');
for counter:=0 to anzd-1 do begin
if sumdimension[counter]<>-1 then begin
//Feld aus dem Dimension table
APA_Sql.Sqltext.lines.add('
dbo.['+dimbez[counter]+'_table].['+dk[counter,APA[zellespalte,zellezeile].hierstuf
e[counter]]+'],');
end;
end;
for counter:=0 to APA_Input_Screen.Keybox.Items.Count-1 do begin
APA_Sql.Sqltext.lines.add(copy(APA_Input_Screen.Keybox.items[counter],pos('//',APA
_Input_Screen.Keybox.items[counter])+2,3)+'(['+
copy(APA_Input_Screen.Keybox.items[counter],1,pos('//',APA_Input_Screen.Keybox.ite
ms[counter])-1)+'])'+
' AS
['+copy(APA_Input_Screen.Keybox.items[counter],1,pos('//',APA_Input_Screen.Keybox.
items[counter])-1)+'],');
end;
//Beistrich entfernen
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);
APA_Sql.Sqltext.lines.add('FROM dbo.BFT');
for counter:=0 to anzd-1 do begin
//Feld aus dem Dimension table
APA_Sql.Sqltext.lines.add(' INNER JOIN dbo.['+dimbez[counter]+'_table] ON
dbo.BFT.['+dimbez[counter]+'_id]=');
APA_Sql.Sqltext.lines.add('
dbo.['+dimbez[counter]+'_table].['+dimbez[counter]+'_id]');
end;
APA_Sql.Sqltext.lines.add('WHERE ');
for counter:=0 to anzd-1 do begin
//Feld aus dem Dimension table
if counter<>0 then APA_Sql.Sqltext.lines.add(' AND ');
APA_Sql.Sqltext.lines.add('
(dbo.['+dimbez[counter]+'_table].[level]=0)');
end;
APA_Sql.Sqltext.lines.add('GROUP BY ');
for counter:=0 to anzd-1 do begin
- 386 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if sumdimension[counter]<>-1 then begin
//Feld aus dem Dimension table
APA_Sql.Sqltext.lines.add('
dbo.['+dimbez[counter]+'_table].['+dk[counter,APA[zellespalte,zellezeile].hierstuf
e[counter]]+'],');
end;
end;
//Beistrich entfernen
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);
end else begin
//Abfrage aus dem aggregierten Cube
APA_Sql.Sqltext.lines.add('SELECT ');
for counter:=0 to anzd-1 do begin
if sumdimension[counter]<>-1 then begin
//Feld aus dem Dimension table
APA_Sql.Sqltext.lines.add('
dbo.['+dimbez[counter]+'_table].['+dk[counter,APA[zellespalte,zellezeile].hierstuf
e[counter]]+'],');
end;
end;
for counter:=0 to APA_Input_Screen.Keybox.Items.Count-1 do begin
APA_Sql.Sqltext.lines.add(copy(APA_Input_Screen.Keybox.items[counter],pos('//',APA
_Input_Screen.Keybox.items[counter])+2,3)+'(['+
copy(APA_Input_Screen.Keybox.items[counter],1,pos('//',APA_Input_Screen.Keybox.ite
ms[counter])-1)+'])'+
' AS
['+copy(APA_Input_Screen.Keybox.items[counter],1,pos('//',APA_Input_Screen.Keybox.
items[counter])-1)+'],');
end;
//Beistrich entfernen
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);
APA_Sql.Sqltext.lines.add('FROM dbo.BFT');
for counter:=0 to anzd-1 do begin
//Feld aus dem Dimension table
APA_Sql.Sqltext.lines.add(' INNER JOIN dbo.['+dimbez[counter]+'_table] ON
dbo.BFT.['+dimbez[counter]+'_id]=');
APA_Sql.Sqltext.lines.add('
dbo.['+dimbez[counter]+'_table].['+dimbez[counter]+'_id]');
end;
APA_Sql.Sqltext.lines.add('WHERE ');
for counter:=0 to anzd-1 do begin
//Feld aus dem Dimension table
if counter<>0 then APA_Sql.Sqltext.lines.add(' AND ');
APA_Sql.Sqltext.lines.add('
(dbo.['+dimbez[counter]+'_table].[level]='
+inttostr(APA[parentspalte,parentzeile].hierstufe[counter])+')');
end;
APA_Sql.Sqltext.lines.add('GROUP BY ');
for counter:=0 to anzd-1 do begin
if sumdimension[counter]<>-1 then begin
//Feld aus dem Dimension table
APA_Sql.Sqltext.lines.add('
dbo.['+dimbez[counter]+'_table].['+dk[counter,APA[zellespalte,zellezeile].hierstuf
e[counter]]+'],');
end;
end;
- 387 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
//Beistrich entfernen
APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1]:=
copy(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1],1,
length(APA_Sql.Sqltext.lines[APA_Sql.Sqltext.lines.count-1])-1);
end;
finally
CloseFile(fKosten);
end;
APA_Sql.Show;
end;
end.
12.1.10 UNIT APA_HELPUNIT.DFM
object APA_Help: TAPA_Help
Left = 220
Top = 114
Width = 696
Height = 480
Caption = 'APA Help'
Color = clBtnFace
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -11
Font.Name = 'MS Sans Serif'
Font.Style = []
OldCreateOrder = False
Position = poScreenCenter
WindowState = wsMaximized
PixelsPerInch = 96
TextHeight = 13
object APABrowser: TWebBrowser
Left = 0
Top = 41
Width = 688
Height = 364
Align = alClient
TabOrder = 0
ControlData = {
4C0000001B4700009F2500000000000000000000000000000000000000000000
000000004C000000000000000000000001000000E0D057007335CF11AE690800
2B2E126208000000000000004C0000000114020000000000C000000000000046
8000000000000000000000000000000000000000000000000000000000000000
00000000000000000100000000000000000000000000000000000000}
end
object Panel2: TPanel
Left = 0
Top = 405
Width = 688
Height = 41
Align = alBottom
TabOrder = 1
object Button1: TButton
Left = 16
Top = 8
Width = 75
Height = 25
Cancel = True
Caption = 'Close'
TabOrder = 0
OnClick = Button1Click
end
end
object Panel1: TPanel
Left = 0
Top = 0
- 388 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Width = 688
Height = 41
Align = alTop
TabOrder = 2
object Button2: TButton
Left = 16
Top = 8
Width = 75
Height = 25
Caption = 'Back'
TabOrder = 0
OnClick = Button2Click
end
object Button3: TButton
Left = 104
Top = 8
Width = 75
Height = 25
Caption = 'Forward'
TabOrder = 1
OnClick = Button3Click
end
end
end
12.1.11 UNIT APA_HELPUNIT.PAS
unit APA_Helpunit;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, ExtCtrls, OleCtrls, SHDocVw;
type
TAPA_Help = class(TForm)
APABrowser: TWebBrowser;
Panel2: TPanel;
Button1: TButton;
Panel1: TPanel;
Button2: TButton;
Button3: TButton;
procedure Button1Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
procedure Button3Click(Sender: TObject);
private
{ Private-Deklarationen }
public
{ Public-Deklarationen }
end;
var
APA_Help: TAPA_Help;
implementation
{$R *.dfm}
procedure TAPA_Help.Button1Click(Sender: TObject);
begin
Close;
end;
procedure TAPA_Help.Button2Click(Sender: TObject);
begin
try
APABrowser.GoBack;
except
showmessage('Not Possible');
end;
- 389 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end;
procedure TAPA_Help.Button3Click(Sender: TObject);
begin
try
APABrowser.GoForward;
except
showmessage('Not Possible');
end;
end;
end.
12.1.12 UNIT APA_INPUT_DIMENSIONUNIT.DFM
object APA_Insert_Dimension: TAPA_Insert_Dimension
Left = 297
Top = 234
ActiveControl = Dimension
BorderStyle = bsDialog
Caption = 'APA_Insert_Dimension'
ClientHeight = 125
ClientWidth = 320
Color = clBtnFace
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -11
Font.Name = 'MS Sans Serif'
Font.Style = []
OldCreateOrder = False
Position = poScreenCenter
OnShow = FormShow
PixelsPerInch = 96
TextHeight = 13
object Bevel1: TBevel
Left = 11
Top = 10
Width = 297
Height = 65
Shape = bsFrame
end
object Label1: TLabel
Left = 27
Top = 18
Width = 103
Height = 13
Caption = 'Dimension description'
end
object OKBtn: TButton
Left = 82
Top = 90
Width = 75
Height = 25
Caption = 'OK'
Default = True
Enabled = False
ModalResult = 1
TabOrder = 0
OnClick = OKBtnClick
end
object CancelBtn: TButton
Left = 162
Top = 90
Width = 75
Height = 25
Cancel = True
Caption = 'Cancel'
ModalResult = 2
TabOrder = 1
OnClick = CancelBtnClick
end
object Dimension: TEdit
- 390 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Left = 27
Top = 34
Width = 257
Height = 21
MaxLength = 40
TabOrder = 2
OnChange = DimensionChange
end
end
12.1.13 UNIT APA_INPUT_DIMENSIONUNIT.PAS
unit APA_Input_Dimensionunit;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, ExtCtrls;
type
TAPA_Insert_Dimension = class(TForm)
Bevel1: TBevel;
OKBtn: TButton;
CancelBtn: TButton;
Label1: TLabel;
Dimension: TEdit;
procedure DimensionChange(Sender: TObject);
procedure CancelBtnClick(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure OKBtnClick(Sender: TObject);
private
{ Private-Deklarationen }
public
{ Public-Deklarationen }
end;
var
APA_Insert_Dimension: TAPA_Insert_Dimension;
implementation
{$R *.dfm}
procedure TAPA_Insert_Dimension.DimensionChange(Sender: TObject);
begin
OKBtn.Enabled:=true;
end;
procedure TAPA_Insert_Dimension.CancelBtnClick(Sender: TObject);
begin
Close;
end;
procedure TAPA_Insert_Dimension.FormShow(Sender: TObject);
begin
Dimension.SetFocus;
end;
procedure TAPA_Insert_Dimension.OKBtnClick(Sender: TObject);
var st:string;
begin
if (pos('//',Dimension.Text)<>0) then begin;
showmessage('Sting "//" is not allowed in dimension');
st:=Dimension.Text;
delete(st,pos('//',st),2);
Dimension.Text:=st;
end;
end;
end.
- 391 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
12.1.14 UNIT APA_INPUT_HIERARCHYUNIT.DFM
object APA_Insert_Hierarchy: TAPA_Insert_Hierarchy
Left = 220
Top = 114
ActiveControl = short_hierarchy
BorderStyle = bsDialog
Caption = 'APA_Insert_Hierarchy'
ClientHeight = 209
ClientWidth = 325
Color = clBtnFace
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -11
Font.Name = 'MS Sans Serif'
Font.Style = []
OldCreateOrder = False
Position = poScreenCenter
OnShow = FormShow
PixelsPerInch = 96
TextHeight = 13
object Bevel1: TBevel
Left = 14
Top = 14
Width = 297
Height = 150
Shape = bsFrame
end
object Label1: TLabel
Left = 30
Top = 22
Width = 125
Height = 13
Caption = 'Hierarchy short description'
end
object Label2: TLabel
Left = 30
Top = 70
Width = 122
Height = 13
Caption = 'Hierarchy long description'
end
object Label3: TLabel
Left = 30
Top = 114
Width = 99
Height = 13
Caption = 'Count of datarecords'
end
object OKBtn: TButton
Left = 85
Top = 170
Width = 75
Height = 25
Caption = 'OK'
Default = True
Enabled = False
ModalResult = 1
TabOrder = 3
OnClick = OKBtnClick
end
object CancelBtn: TButton
Left = 165
Top = 170
Width = 75
Height = 25
Cancel = True
Caption = 'Cancel'
ModalResult = 2
TabOrder = 4
OnClick = CancelBtnClick
end
object short_hierarchy: TEdit
- 392 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Left = 30
Top = 38
Width = 131
Height = 21
MaxLength = 10
TabOrder = 0
OnChange = short_hierarchyChange
end
object long_hierarchy: TEdit
Left = 30
Top = 86
Width = 257
Height = 21
MaxLength = 40
TabOrder = 1
OnChange = long_hierarchyChange
end
object datarecords: TMaskEdit
Left = 30
Top = 128
Width = 257
Height = 21
EditMask = '0##############;0; '
MaxLength = 15
TabOrder = 2
Text = '1'
end
end
12.1.15 UNIT APA_INPUT_HIERARCHYUNIT.PAS
unit APA_Input_Hierarchyunit;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, ExtCtrls, Mask;
type
TAPA_Insert_Hierarchy = class(TForm)
Bevel1: TBevel;
OKBtn: TButton;
CancelBtn: TButton;
Label1: TLabel;
short_hierarchy: TEdit;
Label2: TLabel;
long_hierarchy: TEdit;
Label3: TLabel;
datarecords: TMaskEdit;
procedure short_hierarchyChange(Sender: TObject);
procedure long_hierarchyChange(Sender: TObject);
procedure OKBtnClick(Sender: TObject);
procedure CancelBtnClick(Sender: TObject);
procedure FormShow(Sender: TObject);
private
{ Private-Deklarationen }
public
{ Public-Deklarationen }
end;
var
APA_Insert_Hierarchy: TAPA_Insert_Hierarchy;
implementation
{$R *.dfm}
procedure TAPA_Insert_Hierarchy.short_hierarchyChange(Sender: TObject);
begin
if (length(short_hierarchy.Text)<>0)and
(length(long_hierarchy.Text)<>0) then OKBtn.Enabled:=true;
- 393 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end;
procedure TAPA_Insert_Hierarchy.long_hierarchyChange(Sender: TObject);
begin
if (length(short_hierarchy.Text)<>0)and
(length(long_hierarchy.Text)<>0) then OKBtn.Enabled:=true;
end;
procedure TAPA_Insert_Hierarchy.OKBtnClick(Sender: TObject);
var st:string;
begin
{Überprüfe, ob // nicht im shortstring vorkommt}
if (pos('//',short_hierarchy.Text)<>0) then begin;
showmessage('Sting "//" is not allowed in short description');
st:=short_hierarchy.Text;
delete(st,pos('//',st),2);
short_hierarchy.Text:=st;
end;
if (pos('//',long_hierarchy.Text)<>0) then begin;
showmessage('Sting "//" is not allowed in long description');
st:=long_hierarchy.Text;
delete(st,pos('//',st),2);
long_hierarchy.Text:=st;
end;
if (pos('//',datarecords.Text)<>0) then begin;
showmessage('Sting "//" is not allowed in datarecords');
st:=datarecords.Text;
delete(st,pos('//',st),2);
datarecords.Text:=st;
end;
if (pos('::',short_hierarchy.Text)<>0) then begin;
showmessage('Sting "::" is not allowed in short description');
st:=short_hierarchy.Text;
delete(st,pos('//',st),2);
short_hierarchy.Text:=st;
end;
if (pos('::',long_hierarchy.Text)<>0) then begin;
showmessage('Sting "::" is not allowed in long description');
st:=long_hierarchy.Text;
delete(st,pos('::',st),2);
long_hierarchy.Text:=st;
end;
if (pos('::',datarecords.Text)<>0) then begin;
showmessage('Sting "::" is not allowed in datarecords');
st:=datarecords.Text;
delete(st,pos('::',st),2);
datarecords.Text:=st;
end;
try
if strtoint(datarecords.Text)<0 then
begin
showmessage('Count of datarecords has to be at minimum 1.');
datarecords.Text:='1';
end;
except
showmessage('Unallowed Integer in datarecords. Set to 0.');
datarecords.Text:='0';
end;
end;
procedure TAPA_Insert_Hierarchy.CancelBtnClick(Sender: TObject);
begin
Close;
- 394 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end;
procedure TAPA_Insert_Hierarchy.FormShow(Sender: TObject);
begin
short_hierarchy.SetFocus;
end;
end.
12.1.16 UNIT APA_INPUT_REQBLOCKUNIT.DFM
object APA_Insert_Hierarchy: TAPA_Insert_Hierarchy
Left = 220
Top = 114
ActiveControl = short_hierarchy
BorderStyle = bsDialog
Caption = 'APA_Insert_Hierarchy'
ClientHeight = 209
ClientWidth = 325
Color = clBtnFace
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -11
Font.Name = 'MS Sans Serif'
Font.Style = []
OldCreateOrder = False
Position = poScreenCenter
OnShow = FormShow
PixelsPerInch = 96
TextHeight = 13
object Bevel1: TBevel
Left = 14
Top = 14
Width = 297
Height = 150
Shape = bsFrame
end
object Label1: TLabel
Left = 30
Top = 22
Width = 125
Height = 13
Caption = 'Hierarchy short description'
end
object Label2: TLabel
Left = 30
Top = 70
Width = 122
Height = 13
Caption = 'Hierarchy long description'
end
object Label3: TLabel
Left = 30
Top = 114
Width = 99
Height = 13
Caption = 'Count of datarecords'
end
object OKBtn: TButton
Left = 85
Top = 170
Width = 75
Height = 25
Caption = 'OK'
Default = True
Enabled = False
ModalResult = 1
TabOrder = 3
OnClick = OKBtnClick
end
object CancelBtn: TButton
Left = 165
- 395 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Top = 170
Width = 75
Height = 25
Cancel = True
Caption = 'Cancel'
ModalResult = 2
TabOrder = 4
OnClick = CancelBtnClick
end
object short_hierarchy: TEdit
Left = 30
Top = 38
Width = 131
Height = 21
MaxLength = 10
TabOrder = 0
OnChange = short_hierarchyChange
end
object long_hierarchy: TEdit
Left = 30
Top = 86
Width = 257
Height = 21
MaxLength = 40
TabOrder = 1
OnChange = long_hierarchyChange
end
object datarecords: TMaskEdit
Left = 30
Top = 128
Width = 257
Height = 21
EditMask = '0##############;0; '
MaxLength = 15
TabOrder = 2
Text = '1'
end
end
12.1.17 UNIT APA_INPUT_REQBLOCKUNIT.PAS
unit APA_Input_Reqblockunit;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, ExtCtrls;
type
TAPA_Insert_Reqblock = class(TForm)
Bevel1: TBevel;
OKBtn: TButton;
CancelBtn: TButton;
Label1: TLabel;
Reqname: TEdit;
Add_max_hier: TCheckBox;
Importance_of_requirement: TListBox;
Label2: TLabel;
procedure FormShow(Sender: TObject);
procedure Importance_of_requirementClick(Sender: TObject);
procedure ReqnameChange(Sender: TObject);
private
{ Private-Deklarationen }
public
{ Public-Deklarationen }
end;
var
APA_Insert_Reqblock: TAPA_Insert_Reqblock;
implementation
- 396 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
uses APA_Parameterunit;
{$R *.dfm}
procedure TAPA_Insert_Reqblock.FormShow(Sender: TObject);
var merkindex,g:longint;//Zähler
begin
merkindex:=Importance_of_requirement.ItemIndex;
Reqname.SetFocus;
Importance_of_requirement.Items.Clear;
//Festlegen der Required Spalten
for g:=0 to APA_Parameter.APA_Degrees.Count-1 do begin
Importance_of_requirement.Items.Add(APA_Parameter.APA_Degrees.Items[g]);
end;
Importance_of_requirement.ItemIndex:=merkindex;
if Importance_of_requirement.ItemIndex=-1 then Importance_of_requirement.ItemIndex:=0;
end;
procedure TAPA_Insert_Reqblock.Importance_of_requirementClick(
Sender: TObject);
begin
OKBtn.Enabled:=true;
end;
procedure TAPA_Insert_Reqblock.ReqnameChange(Sender: TObject);
begin
OKBtn.Enabled:=true;
end;
end.
12.1.18 UNIT APA_INPUT_SCREENUNIT.DFM
object APA_Input_Screen: TAPA_Input_Screen
Left = 206
Top = 119
Width = 604
Height = 568
Caption = 'APA Input Screen'
Color = clBtnFace
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -11
Font.Name = 'MS Sans Serif'
Font.Style = []
OldCreateOrder = False
Position = poScreenCenter
OnCloseQuery = FormCloseQuery
OnShow = FormShow
PixelsPerInch = 96
TextHeight = 13
object Panel1: TPanel
Left = 0
Top = 493
Width = 596
Height = 41
Align = alBottom
TabOrder = 0
object Saveandexit_button: TButton
Left = 16
Top = 8
Width = 75
Height = 25
Caption = 'Save && Exit'
Enabled = False
ModalResult = 1
TabOrder = 0
OnClick = Saveandexit_buttonClick
end
- 397 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
object Abortandexit_button: TButton
Left = 104
Top = 8
Width = 75
Height = 25
Caption = 'Abort && Exit'
ModalResult = 2
TabOrder = 1
OnClick = Abortandexit_buttonClick
end
end
object Panel2: TPanel
Left = 0
Top = 0
Width = 596
Height = 41
Align = alTop
TabOrder = 1
object Button_insert_dimension: TButton
Left = 8
Top = 8
Width = 90
Height = 25
Caption = 'Insert dimension'
TabOrder = 0
OnClick = Button_insert_dimensionClick
end
object Button_delete: TButton
Left = 220
Top = 8
Width = 90
Height = 25
Caption = 'Delete'
TabOrder = 2
OnClick = Button_deleteClick
end
object Button_Edit: TButton
Left = 327
Top = 8
Width = 90
Height = 25
Caption = 'Edit'
TabOrder = 3
OnClick = Button_EditClick
end
object Button_insert_hierarchy: TButton
Left = 114
Top = 8
Width = 90
Height = 25
Caption = 'Insert hierarchy'
TabOrder = 1
OnClick = Button_insert_hierarchyClick
end
end
object Panel3: TPanel
Left = 0
Top = 41
Width = 65
Height = 340
Align = alLeft
TabOrder = 2
object APA_dimbox: TGroupBox
Left = 1
Top = 1
Width = 63
Height = 72
Align = alTop
Caption = 'Dimension'
Enabled = False
TabOrder = 0
object Button_dim_up: TButton
Left = 8
Top = 16
- 398 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Width = 50
Height = 25
Caption = 'Up'
TabOrder = 0
OnClick = Button_dim_upClick
end
object Button_dim_down: TButton
Left = 8
Top = 42
Width = 50
Height = 25
Caption = 'Down'
TabOrder = 1
OnClick = Button_dim_downClick
end
end
object APA_hierbox: TGroupBox
Left = 1
Top = 73
Width = 63
Height = 73
Align = alTop
Caption = 'Hierarchy'
Enabled = False
TabOrder = 1
object button_hier_up: TButton
Left = 8
Top = 16
Width = 50
Height = 25
Caption = 'Up'
TabOrder = 0
OnClick = button_hier_upClick
end
object Button_hier_down: TButton
Left = 8
Top = 42
Width = 50
Height = 25
Caption = 'Down'
TabOrder = 1
OnClick = Button_hier_downClick
end
end
end
object GroupBox1: TGroupBox
Left = 0
Top = 381
Width = 596
Height = 112
Align = alBottom
Caption = 'Key figures'
TabOrder = 3
object Panel4: TPanel
Left = 2
Top = 15
Width = 95
Height = 95
Align = alLeft
TabOrder = 0
object Button_key_insert: TButton
Left = 5
Top = 7
Width = 75
Height = 25
Caption = 'Insert'
TabOrder = 0
OnClick = Button_key_insertClick
end
object Button_key_edit: TButton
Left = 5
Top = 35
Width = 75
Height = 25
- 399 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Caption = 'Edit'
TabOrder = 1
OnClick = Button_key_editClick
end
object Button_key_delete: TButton
Left = 5
Top = 62
Width = 75
Height = 25
Caption = 'Delete'
TabOrder = 2
OnClick = Button_key_deleteClick
end
end
object Keybox: TListBox
Left = 97
Top = 15
Width = 497
Height = 95
Align = alClient
ItemHeight = 13
Items.Strings = (
'Profit//SUM(MONEY)'
'')
TabOrder = 1
OnDblClick = KeyboxDblClick
end
end
object Eingabe: TTreeView
Left = 65
Top = 41
Width = 531
Height = 340
Align = alClient
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -13
Font.Name = 'MS Sans Serif'
Font.Style = []
HideSelection = False
Images = APA_ImageList
Indent = 19
ParentFont = False
ReadOnly = True
TabOrder = 4
OnClick = EingabeClick
OnMouseUp = EingabeMouseUp
Items.Data = {
010000001D000000010000000100000001000000FFFFFFFF0000000004000000
0454696D6527000000020000000200000002000000FFFFFFFF00000000000000
000E5A5F642F2F5461673A3A3336353028000000020000000200000002000000
FFFFFFFF00000000000000000F5A5F6D2F2F4D6F6E74683A3A31323026000000
020000000200000002000000FFFFFFFF00000000000000000D5A5F792F2F5965
61723A3A31302B000000020000000200000002000000FFFFFFFF000000000000
0000125A5F2A2F2F54696D6520746F74616C3A3A31}
end
object Eingabemerk: TTreeView
Left = 432
Top = 272
Width = 97
Height = 57
Indent = 19
TabOrder = 5
Visible = False
end
object Keyboxmerk: TListBox
Left = 448
Top = 160
Width = 81
Height = 57
ItemHeight = 13
TabOrder = 6
Visible = False
end
- 400 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
object APA_popup: TPopupMenu
Left = 424
Top = 64
object Insertdimension1: TMenuItem
Caption = 'Insert dimension'
OnClick = Insertdimension1Click
end
object Inserthierarchy1: TMenuItem
Caption = 'Insert hierarchy'
OnClick = Inserthierarchy1Click
end
object Delete1: TMenuItem
Caption = 'Delete'
OnClick = Delete1Click
end
object Edit1: TMenuItem
Caption = 'Edit'
OnClick = Edit1Click
end
object N1: TMenuItem
Caption = '-'
end
object Dimensionup1: TMenuItem
Caption = 'Dimension up'
OnClick = Dimensionup1Click
end
object Dimensiondown1: TMenuItem
Caption = 'Dimension down'
OnClick = Dimensiondown1Click
end
object N2: TMenuItem
Caption = '-'
end
object Hierarchyup1: TMenuItem
Caption = 'Hierarchy up'
OnClick = Hierarchyup1Click
end
object Hierarchydown1: TMenuItem
Caption = 'Hierarchy down'
ImageIndex = 0
OnClick = Hierarchydown1Click
end
end
object APA_ImageList: TImageList
Left = 504
Top = 72
Bitmap = {
494C010103000400040010001000FFFFFFFFFF10FFFFFFFFFFFFFFFF424D3600
0000000000003600000028000000400000001000000001002000000000000010
000000000000000000000000000000000000344E4A006BB09B006BB09B006BB0
. . .
. . .
0000800100010000000080010001000000008001000100000000800100010000
0000800100010000000080010001000000008001000100000000800100010000
00008001000100000000FFFFFFFF000000000000000000000000000000000000
000000000000}
end
end
12.1.19 UNIT APA_INPUT_SCREENUNIT.PAS
unit APA_Input_Screenunit;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, ImgList, ComCtrls, Menus, StdCtrls, ExtCtrls;
type
TAPA_Input_Screen = class(TForm)
Panel1: TPanel;
- 401 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Saveandexit_button: TButton;
Abortandexit_button: TButton;
Panel2: TPanel;
Button_insert_dimension: TButton;
Button_delete: TButton;
Button_Edit: TButton;
Button_insert_hierarchy: TButton;
Panel3: TPanel;
APA_dimbox: TGroupBox;
Button_dim_up: TButton;
Button_dim_down: TButton;
APA_hierbox: TGroupBox;
button_hier_up: TButton;
Button_hier_down: TButton;
GroupBox1: TGroupBox;
Panel4: TPanel;
Button_key_insert: TButton;
Button_key_edit: TButton;
Button_key_delete: TButton;
Keybox: TListBox;
APA_popup: TPopupMenu;
Insertdimension1: TMenuItem;
Inserthierarchy1: TMenuItem;
Delete1: TMenuItem;
Edit1: TMenuItem;
N1: TMenuItem;
Dimensionup1: TMenuItem;
Dimensiondown1: TMenuItem;
N2: TMenuItem;
Hierarchyup1: TMenuItem;
Hierarchydown1: TMenuItem;
Eingabe: TTreeView;
APA_ImageList: TImageList;
Eingabemerk: TTreeView;
Keyboxmerk: TListBox;
procedure Button_insert_dimensionClick(Sender: TObject);
procedure Button_EditClick(Sender: TObject);
procedure Button_deleteClick(Sender: TObject);
procedure Button_insert_hierarchyClick(Sender: TObject);
procedure Delete1Click(Sender: TObject);
procedure Insertdimension1Click(Sender: TObject);
procedure Inserthierarchy1Click(Sender: TObject);
procedure Edit1Click(Sender: TObject);
procedure Dimensionup1Click(Sender: TObject);
procedure Dimensiondown1Click(Sender: TObject);
procedure Hierarchyup1Click(Sender: TObject);
procedure Hierarchydown1Click(Sender: TObject);
procedure Button_dim_upClick(Sender: TObject);
procedure Button_dim_downClick(Sender: TObject);
procedure button_hier_upClick(Sender: TObject);
procedure Button_hier_downClick(Sender: TObject);
procedure Saveandexit_buttonClick(Sender: TObject);
procedure EingabeClick(Sender: TObject);
procedure EingabeMouseUp(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
procedure Button_key_insertClick(Sender: TObject);
procedure Button_key_deleteClick(Sender: TObject);
procedure Button_key_editClick(Sender: TObject);
procedure KeyboxDblClick(Sender: TObject);
procedure Abortandexit_buttonClick(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure FormCloseQuery(Sender: TObject; var CanClose: Boolean);
private
{ Private-Deklarationen }
public
{ Public-Deklarationen }
end;
var
APA_Input_Screen: TAPA_Input_Screen;
generiereapaneu:boolean=true;
implementation
uses APA_Input_Dimensionunit, APA_Input_Hierarchyunit, APA_Keyunit, APA_Gridunit,
- 402 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
APA_Applicationunit, APA_Dialogunit;
{$R *.dfm}
var neuekosten:boolean;
procedure TAPA_Input_Screen.Button_insert_dimensionClick(Sender: TObject);
var merkex:longint;
var ok:boolean;
begin
mustsave:=true;
if (Eingabe.Selected<>Nil) then begin
{Setze den Zeiger auf eine Dimension oder auf das erste Element}
while (Eingabe.Selected.ImageIndex<>1)and(Eingabe.Selected.GetPrev<>nil) do
Eingabe.Selected:=Eingabe.Selected.GetPrev;
end;
{Eine Dimension}
APA_Insert_Dimension.Dimension.Text:='';
APA_Insert_Dimension.OKBtn.Enabled:=false;
repeat;
ok:=true;
if APA_Insert_Dimension.showmodal=mrOK then begin
for merkex:=0 to Eingabe.Items.Count-1 do begin
if Eingabe.Items[merkex].ImageIndex=1 then begin
if Eingabe.Items[merkex].Text=APA_Insert_Dimension.Dimension.Text then begin
showmessage('The name '+APA_Insert_Dimension.Dimension.Text+' for a dimension is
already used. Please change the name!');
ok:=false;
end;
end;
end;
if ok=true then begin
merkex:=Eingabe.Items.Add(Eingabe.Selected,APA_Insert_Dimension.Dimension.Text).Ab
soluteIndex;
Eingabe.Items[merkex].ImageIndex:=1;
Eingabe.Items[merkex].SelectedIndex:=1;
Saveandexit_button.Enabled:=true;
generiereapaneu:=true;
end;
end else ok:=true;
until ok=true;
{Eine Dimension ENDE}
Eingabeclick(self);
if (Eingabe.Selected<>Nil) then Eingabe.Selected.Expanded:=true;
end;
procedure TAPA_Input_Screen.Button_EditClick(Sender: TObject);
var ok:boolean;
var merkex:longint;
begin
mustsave:=true;
if (Eingabe.Selected.ImageIndex=1) then begin
{Eine Dimension}
APA_Insert_Dimension.Dimension.Text:=Eingabe.Selected.Text;
APA_Insert_Dimension.OKBtn.Enabled:=false;
repeat;
ok:=true;
if APA_Insert_Dimension.showmodal=mrOK then begin
for merkex:=0 to Eingabe.Items.Count-1 do begin
if Eingabe.Items[merkex].ImageIndex=1 then begin
if (Eingabe.Items[merkex].Text=APA_Insert_Dimension.Dimension.Text)and
(merkex<>Eingabe.Selected.AbsoluteIndex)
then begin
showmessage('The name '+APA_Insert_Dimension.Dimension.Text+' for a dimension is
already used. Please change the name!');
ok:=false;
- 403 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end;
end;
end;
if ok=true then begin
Eingabe.Selected.Text:=APA_Insert_Dimension.Dimension.Text;
Saveandexit_button.Enabled:=true;
generiereapaneu:=true;
end;
end else ok:=true;
until ok=true;
{Eine Dimension ENDE}
end else begin
{Eine Hierarchy}
APA_Insert_Hierarchy.short_hierarchy.Text:=
copy(Eingabe.Selected.Text,1,pos('//',Eingabe.Selected.Text)-1);
APA_Insert_Hierarchy.long_hierarchy.Text:=
copy(Eingabe.Selected.Text,pos('//',Eingabe.Selected.Text)+2,pos('::',Eingabe.Sele
cted.Text)-(pos('//',Eingabe.Selected.Text)+2));
APA_Insert_Hierarchy.datarecords.Text:=
copy(Eingabe.Selected.Text,pos('::',Eingabe.Selected.Text)+2,255);
APA_Insert_Hierarchy.OKBtn.Enabled:=false;
repeat;
ok:=true;
if APA_Insert_Hierarchy.showmodal=mrOK then begin
for merkex:=0 to Eingabe.Items.Count-1 do begin
if Eingabe.Items[merkex].ImageIndex=2 then begin
if (copy(Eingabe.Items[merkex].Text,1,pos('//',Eingabe.Items[merkex].Text)1)=APA_Insert_Hierarchy.short_hierarchy.Text)and
(merkex<>Eingabe.Selected.AbsoluteIndex) then begin
showmessage('The name '+APA_Insert_Hierarchy.short_hierarchy.Text+' for a short
hierarchy is already used. Please change the name!');
ok:=false;
end;
end;
end;
if ok=true then begin
Eingabe.Selected.Text:=
APA_Insert_Hierarchy.short_hierarchy.Text+'//'+APA_Insert_Hierarchy.long_hierarchy
.Text+'::'+
APA_Insert_Hierarchy.datarecords.Text;
Saveandexit_button.Enabled:=true;
generiereapaneu:=true;
end;
end else ok:=true;
until ok=true;
{Eine Hierarchy ENDE}
end;
Eingabeclick(self);
end;
procedure TAPA_Input_Screen.Button_deleteClick(Sender: TObject);
begin
mustsave:=true;
if Eingabe.Selected<>nil then begin
if Eingabe.Selected.ImageIndex=2 then neuekosten:=true;
Eingabe.Items.Delete(Eingabe.Selected);
Saveandexit_button.Enabled:=true;
generiereapaneu:=true;
end else showmessage('No dimension or hierarchy selected.');
Eingabeclick(self);
end;
procedure TAPA_Input_Screen.Button_insert_hierarchyClick(Sender: TObject);
var merkex:longint;
- 404 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
var ok:boolean;
var counter,merkdatacount,merkdatacount2:longint;
var merketext1,merketext2:string;
begin
mustsave:=true;
if Eingabe.Selected<>nil then begin
{Eine Hierarchy}
APA_Insert_Hierarchy.short_hierarchy.Text:='';
APA_Insert_Hierarchy.long_hierarchy.Text:='';
APA_Insert_Hierarchy.OKBtn.Enabled:=false;
repeat;
ok:=true;
if APA_Insert_Hierarchy.showmodal=mrOK then begin
for merkex:=0 to Eingabe.Items.Count-1 do begin
if Eingabe.Items[merkex].ImageIndex=2 then begin
if copy(Eingabe.Items[merkex].Text,1,pos('//',Eingabe.Items[merkex].Text)1)=APA_Insert_Hierarchy.short_hierarchy.Text then begin
showmessage('The name '+APA_Insert_Hierarchy.short_hierarchy.Text+' for a short
hierarchy is already used. Please change the name!');
ok:=false;
end;
end;
end;
if ok=true then begin
if Eingabe.Selected.ImageIndex=1 then begin;
{wenn Dimension markiert}
merkex:=Eingabe.Items.AddChild(Eingabe.Selected,
APA_Insert_Hierarchy.short_hierarchy.Text+'//'+APA_Insert_Hierarchy.long_hierarchy
.Text
+'::'+APA_Insert_Hierarchy.datarecords.Text).AbsoluteIndex;
Eingabe.Items[merkex].ImageIndex:=2;
Eingabe.Items[merkex].SelectedIndex:=2;
end
else
{wenn Hierarchy markiert}
merkex:=Eingabe.Items.Add(Eingabe.Selected,
APA_Insert_Hierarchy.short_hierarchy.Text+'//'+APA_Insert_Hierarchy.long_hierarchy
.Text
+'::'+APA_Insert_Hierarchy.datarecords.Text).AbsoluteIndex;
Eingabe.Items[merkex].ImageIndex:=2;
Eingabe.Items[merkex].SelectedIndex:=2;
Saveandexit_button.Enabled:=true;
generiereapaneu:=true;
neuekosten:=true;
end;//von ok
end else ok:=true;
until ok=true;
{Eine Hierarchy ENDE}
end else showmessage('No Item selected!');
Eingabeclick(self);
if (Eingabe.Selected<>Nil) then Eingabe.Selected.Expanded:=true;
//Sortieren der Hierarchien
counter:=0;
repeat;
if (counter<Eingabe.Items.Count-2) then begin
if (Eingabe.Items[counter].ImageIndex<>1)and
(Eingabe.Items[counter+1].ImageIndex<>1) then begin
//Wenn zwei Hierarchien
merkdatacount:=strtoint(copy(Eingabe.Items[counter].Text,pos('::',Eingabe.Items[co
unter].Text)+2,255));
- 405 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
merkdatacount2:=strtoint(copy(Eingabe.Items[counter+1].Text,pos('::',Eingabe.Items
[counter+1].Text)+2,255));
if merkdatacount<merkdatacount2 then begin
//Austauschen
merketext1:=Eingabe.Items[counter].Text;
merketext2:=Eingabe.Items[counter+1].Text;
Eingabe.Items[counter].Text:=merketext2;
Eingabe.Items[counter+1].Text:=merketext1;
counter:=counter-2;if counter<-1 then counter:=-1;
end;
end;
end;
counter:=counter+1;
until (counter>=Eingabe.Items.Count-1)
end;
procedure TAPA_Input_Screen.Delete1Click(Sender: TObject);
begin
Button_Delete.Click;
end;
procedure TAPA_Input_Screen.Insertdimension1Click(Sender: TObject);
begin
Button_Insert_dimension.Click;
end;
procedure TAPA_Input_Screen.Inserthierarchy1Click(Sender: TObject);
begin
Button_Insert_Hierarchy.Click;
end;
procedure TAPA_Input_Screen.Edit1Click(Sender: TObject);
begin
Button_Edit.Click;
end;
procedure TAPA_Input_Screen.Dimensionup1Click(Sender: TObject);
begin
Button_dim_up.Click;
end;
procedure TAPA_Input_Screen.Dimensiondown1Click(Sender: TObject);
begin
Button_dim_down.Click;
end;
procedure TAPA_Input_Screen.Hierarchyup1Click(Sender: TObject);
begin
Button_hier_up.Click;
end;
procedure TAPA_Input_Screen.Hierarchydown1Click(Sender: TObject);
begin
Button_hier_down.Click;
end;
procedure TAPA_Input_Screen.Button_dim_upClick(Sender: TObject);
begin
mustsave:=true;
if Eingabe.Selected<>nil then
if Eingabe.Selected.ImageIndex=1 then
if (Eingabe.Selected.getPrevSibling<>Nil) then
if Eingabe.Selected.getPrevSibling.ImageIndex=1 then
Eingabe.Selected.MoveTo(Eingabe.Selected.getPrevSibling,naInsert);
- 406 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Eingabeclick(self);
Saveandexit_button.Enabled:=true;
generiereapaneu:=true;
Eingabe.Repaint;
end;
procedure TAPA_Input_Screen.Button_dim_downClick(Sender: TObject);
begin
mustsave:=true;
if Eingabe.Selected<>nil then
if Eingabe.Selected.ImageIndex=1 then
if Eingabe.Selected.getNextSibling<>nil then
if Eingabe.Selected.getNextSibling.ImageIndex=1 then
Eingabe.Selected.getNextSibling.MoveTo(Eingabe.Selected,naInsert);
Eingabeclick(self);
Saveandexit_button.Enabled:=true;
generiereapaneu:=true;
end;
procedure TAPA_Input_Screen.button_hier_upClick(Sender: TObject);
var merke1,merke2:string;
begin
mustsave:=true;
if Eingabe.Selected<>nil then
if Eingabe.Selected.ImageIndex=2 then
if Eingabe.Selected.GetPrev<>Nil then
if (Eingabe.Selected.GetPrev.ImageIndex=2) then begin;
merke1:=Eingabe.Selected.Text;
merke2:=Eingabe.Selected.getprev.Text;
if strtoint(copy(merke2,pos('::',merke2)+2,255))>
strtoint(copy(merke1,pos('::',merke1)+2,255)) then
begin;
Eingabe.Selected.Text:=copy(merke1,1,pos('::',merke1)+1)+
copy(merke2,pos('::',merke2)+2,255);
Eingabe.Selected.Getprev.Text:=copy(merke2,1,pos('::',merke2)+1)+
copy(merke1,pos('::',merke1)+2,255);
end;
Eingabe.Selected.MoveTo(Eingabe.Selected.GetPrev,naInsert);
end;
Eingabeclick(self);
Saveandexit_button.Enabled:=true;
generiereapaneu:=true;
end;
procedure TAPA_Input_Screen.Button_hier_downClick(Sender: TObject);
var merke1,merke2:string;
begin
mustsave:=true;
if Eingabe.Selected<>nil then
if Eingabe.Selected.ImageIndex=2 then
If Eingabe.Selected.GetNext<>nil then
If Eingabe.Selected.GetNext.ImageIndex=2 then begin;
merke1:=Eingabe.Selected.Text;
merke2:=Eingabe.Selected.getnext.Text;
if strtoint(copy(merke2,pos('::',merke2)+2,255))<
strtoint(copy(merke1,pos('::',merke1)+2,255)) then
begin;
Eingabe.Selected.Text:=copy(merke1,1,pos('::',merke1)+1)+
copy(merke2,pos('::',merke2)+2,255);
Eingabe.Selected.GetNext.Text:=copy(merke2,1,pos('::',merke2)+1)+
copy(merke1,pos('::',merke1)+2,255);
- 407 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end;
Eingabe.Selected.GetNext.MoveTo(Eingabe.Selected,naInsert);
end;
Eingabeclick(self);
Saveandexit_button.Enabled:=true;
generiereapaneu:=true;
end;
procedure buttonchange;
begin;
with APA_Input_Screen do begin
if Eingabe.Selected<>nil then begin
if Eingabe.Selected.ImageIndex=1 then begin
{dimension}
APA_dimbox.Enabled:=true;
APA_hierbox.Enabled:=false;
If Eingabe.Selected.getPrevSibling<>nil then
Button_dim_up.Enabled:=true else Button_dim_up.Enabled:=false;
If Eingabe.Selected.getNextSibling<>nil then
Button_dim_down.Enabled:=true else Button_dim_down.Enabled:=false;
button_hier_up.Enabled:=false;
Button_hier_down.Enabled:=false;
end else
begin
{Hierarchy}
APA_dimbox.Enabled:=false;
APA_hierbox.Enabled:=true;
Button_dim_up.Enabled:=false;
Button_dim_down.Enabled:=false;
If Eingabe.Selected.getPrevSibling<>nil then
Button_hier_up.Enabled:=true else Button_hier_up.Enabled:=false;
If Eingabe.Selected.getNextSibling<>nil then
Button_hier_down.Enabled:=true else Button_hier_down.Enabled:=false;
end;
end else
begin
APA_dimbox.Enabled:=false;
APA_hierbox.Enabled:=false;
Button_dim_up.Enabled:=false;
Button_dim_down.Enabled:=false;
button_hier_up.Enabled:=false;
Button_hier_down.Enabled:=false;
end;
end;
end;
procedure TAPA_Input_Screen.Saveandexit_buttonClick(Sender: TObject);
var counter,maxchilds,merkdatacount:longint;
CurItem,lastdim,nrmaxchilds:TTreeNode;
begin
Saveandexit_button.Enabled:=false;
mustsave:=true;
//Überprüfe die richte Anordung der Hierarchien
merkdatacount:=0;
for counter:=0 to Eingabe.Items.Count-1 do begin
If Eingabe.Items[counter].ImageIndex=1 then begin
//Wert neu
merkdatacount:=0;
end else begin
if ((merkdatacount=0)or
(merkdatacount>
strtoint(copy(Eingabe.Items[counter].Text,pos('::',Eingabe.Items[counter].Text)+2,
255))))
then begin
- 408 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
merkdatacount:=strtoint(copy(Eingabe.Items[counter].Text,pos('::',Eingabe.Items[co
unter].Text)+2,255));
end else begin
//Fehler
showmessage('Hierarchies are not in right order. Please check '+
copy(Eingabe.Items[counter].Text,pos('//',Eingabe.Items[counter].Text)+2,
pos('::',Eingabe.Items[counter].Text)-(pos('//',Eingabe.Items[counter].Text)+2)));
exit;
end;
end;
end;
if generiereapaneu=true then begin
{Setze die Dimension mit den meisten Unterknoten nach unten}
lastdim:=nil;
CurItem:=Eingabe.Items.GetFirstNode;nrmaxchilds:=CurItem;
while nrmaxchilds<>lastdim do begin
CurItem:=Eingabe.Items.GetFirstNode;nrmaxchilds:=CurItem;
maxchilds:=0;
while CurItem<>nil do begin
if maxchilds<=CurItem.Count then begin
maxchilds:=CurItem.Count;
nrmaxchilds:=CurItem;
end;
if CurItem.HasChildren=true then lastdim:=CurItem;
CurItem:=CurItem.GetNext;
end;
if (nrmaxchilds<>lastdim) then begin
nrmaxchilds.Selected:=true;button_dim_down.Click;
showmessage('Place dimension with maximal hierarchy levels on last position');
end;
end;
{Setze die Dimension mit den meisten Unterknoten nach oben ENDE}
{Demarkiere den Apa_Selektion Screen}
APA_Application.Button_Apa_Selection.Enabled:=false;
if generiereapaneu=true then begin
APA_Grid.FormShow(self);
end;
if neuekosten=true then begin
APA_Dialog.APA_Text.Caption:= 'You have changed the Input Data. You have to generate
the random costs again. Do you want to generate the random costs now?';
if APA_Dialog.showmodal=mryes then
APA_Application.GeneriereZufallskosten1Click(self);;
end;
end;
end;
procedure TAPA_Input_Screen.EingabeClick(Sender: TObject);
begin
buttonchange;
end;
procedure TAPA_Input_Screen.EingabeMouseUp(Sender: TObject;
Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
buttonchange;
end;
procedure TAPA_Input_Screen.Button_key_insertClick(Sender: TObject);
var ok:boolean;
var counter:longint;
begin
- 409 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
mustsave:=true;
Saveandexit_button.Enabled:=true;
mustsave:=true;
APA_Insert_Key.Key_Fieldname.Text:='';
APA_Insert_Key.APA_Function.ItemIndex:=0;
APA_Insert_Key.APA_Field_type.ItemIndex:=4;
APA_Insert_Key.OKBtn.enabled:=false;
repeat;
ok:=true;
if APA_Insert_Key.showmodal=mrOK then begin
for counter:=0 to Keybox.Items.Count-1 do begin
if (APA_Insert_Key.Key_fieldname.Text=
copy(Keybox.items[counter],1,pos('//',Keybox.items[counter])-1)) then begin
ok:=false;
showmessage('The name '+APA_Insert_Key.Key_fieldname.Text+' is already used.
Please change the name!');
end;
end;
if ok=true then begin
Keybox.Items.Add(APA_Insert_Key.Key_fieldname.Text+'//'+APA_Insert_Key.APA_Functio
n.Items[APA_Insert_Key.APA_Function.itemindex]
+'('+APA_Insert_Key.APA_Field_type.Items[APA_Insert_Key.APA_Field_type.itemindex]+
')');
Saveandexit_button.Enabled:=true;
end;
end else ok:=true;
until ok=true;
end;
procedure TAPA_Input_Screen.Button_key_deleteClick(Sender: TObject);
begin
mustsave:=true;
if keybox.ItemIndex<>-1 then begin
Saveandexit_button.Enabled:=true;
Keybox.Items.Delete(Keybox.ItemIndex);
mustsave:=true;
end
else
showmessage('No Key figure selected');
end;
procedure TAPA_Input_Screen.Button_key_editClick(Sender: TObject);
var ok:boolean;
counter:longint;
begin
mustsave:=true;
if Keybox.ItemIndex<>-1 then begin
APA_Insert_Key.APA_Function.ItemIndex:=
APA_Insert_Key.APA_Function.Items.IndexOf(copy(Keybox.items[Keybox.itemindex],pos(
'//',
Keybox.items[Keybox.itemindex])+2,3));
APA_Insert_Key.Key_fieldname.Text:=
copy(Keybox.items[Keybox.itemindex],1,pos('//',Keybox.items[Keybox.itemindex])-1);
APA_Insert_Key.APA_Field_type.ItemIndex:=
APA_Insert_Key.APA_Field_type.Items.IndexOf(
copy(Keybox.items[Keybox.itemindex],pos('//',Keybox.items[Keybox.itemindex])+6,
length(Keybox.items[Keybox.itemindex])-(pos('//',Keybox.items[Keybox.itemindex])+6)));
APA_Insert_Key.OKBtn.enabled:=false;
repeat;
ok:=true;
if APA_Insert_Key.showmodal=mrOK then begin
for counter:=0 to Keybox.Items.Count-1 do begin
if (APA_Insert_Key.Key_fieldname.Text=
copy(Keybox.items[counter],1,pos('//',Keybox.items[counter])-1))
- 410 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
and(counter<>Keybox.ItemIndex)
then begin
ok:=false;
showmessage('The name '+APA_Insert_Key.Key_fieldname.Text+' is already used.
Please change the name!');
end;
end;
if ok=true then begin
Keybox.Items[Keybox.ItemIndex]:=APA_Insert_Key.Key_fieldname.Text+'//'+
APA_Insert_Key.APA_Function.Items[APA_Insert_Key.APA_Function.itemindex]
+'('+APA_Insert_Key.APA_Field_type.Items[APA_Insert_Key.APA_Field_type.itemindex]+
')';
Saveandexit_button.Enabled:=true; mustsave:=true;
end;
end else ok:=true;
until ok=true;
end
else showmessage('No Key figure selected');
end;
procedure TAPA_Input_Screen.KeyboxDblClick(Sender: TObject);
begin
Button_key_edit.click;
end;
procedure TAPA_Input_Screen.Abortandexit_buttonClick(Sender: TObject);
begin
Saveandexit_button.Enabled:=false;
keybox.Items.Clear;
keybox.Items:=keyboxmerk.Items;
Eingabe.Items.Clear;
Eingabe.Items:=Eingabemerk.Items;
end;
procedure TAPA_Input_Screen.FormShow(Sender: TObject);
begin
//Speichere die aktuellen Eingabe
keyboxmerk.Items.Clear;
keyboxmerk.Items:=keybox.Items;
Eingabemerk.Items.Clear;
Eingabemerk.Items:=Eingabe.Items;
neuekosten:=false;
end;
procedure TAPA_Input_Screen.FormCloseQuery(Sender: TObject;
var CanClose: Boolean);
var counter, merkcounter:longint;
ok:boolean;
begin
{Kontrolliere, ob jede Dimension mindestens eine Hierarchie hat}
ok:=true;merkcounter:=0;
for counter:=0 to Eingabe.Items.Count-1 do begin
if Eingabe.Items[counter].ImageIndex=1 then begin
//wenn Dimension
if ok=false //dann gibt es eine Hierarchie
then begin
showmessage('The dimension '+Eingabe.Items[merkcounter].Text+' do not have a
hierarchy');
canClose:=false;
end;
ok:=false; merkcounter:=counter;
end else begin
//wenn Hierarchie
ok:=true;
- 411 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end;
end;
if Saveandexit_button.Enabled=true then begin
APA_Dialog.APA_Text.Caption:='Do you want to save your changes?';
if APA_Dialog.showmodal=mryes then Saveandexit_button.Click else
Abortandexit_button.Click;
end;
end;
end.
12.1.20 UNIT APA_KEYUNIT.DFM
object APA_Insert_Key: TAPA_Insert_Key
Left = 234
Top = 185
ActiveControl = Key_fieldname
BorderStyle = bsDialog
Caption = 'APA Insert Key'
ClientHeight = 205
ClientWidth = 321
Color = clBtnFace
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -11
Font.Name = 'MS Sans Serif'
Font.Style = []
OldCreateOrder = False
Position = poScreenCenter
OnShow = FormShow
PixelsPerInch = 96
TextHeight = 13
object Bevel1: TBevel
Left = 12
Top = 16
Width = 297
Height = 145
Shape = bsFrame
end
object Label1: TLabel
Left = 28
Top = 25
Width = 48
Height = 13
Caption = 'Fieldname'
end
object Label2: TLabel
Left = 28
Top = 110
Width = 42
Height = 13
Caption = 'Fieldtype'
end
object Label3: TLabel
Left = 28
Top = 66
Width = 41
Height = 13
Caption = 'Function'
end
object OKBtn: TButton
Left = 83
Top = 172
Width = 75
Height = 25
Caption = 'OK'
Default = True
Enabled = False
ModalResult = 1
- 412 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
TabOrder = 1
OnClick = OKBtnClick
end
object CancelBtn: TButton
Left = 163
Top = 172
Width = 75
Height = 25
Cancel = True
Caption = 'Cancel'
ModalResult = 2
TabOrder = 2
end
object Key_fieldname: TEdit
Left = 28
Top = 41
Width = 257
Height = 21
MaxLength = 40
TabOrder = 0
OnChange = Key_fieldnameChange
end
object APA_Field_type: TComboBox
Left = 28
Top = 126
Width = 249
Height = 21
Style = csDropDownList
ItemHeight = 13
ItemIndex = 0
TabOrder = 3
Text = 'BIGINT'
OnChange = APA_Field_typeChange
Items.Strings = (
'BIGINT'
'INT'
'SMALLINT'
'DECIMAL'
'MONEY'
'SMALLMONEY'
'FLOAT'
'REAL'
'DATETIME'
'SMALLDATETIME')
end
object APA_Function: TComboBox
Left = 28
Top = 82
Width = 145
Height = 21
Style = csDropDownList
ItemHeight = 13
ItemIndex = 0
TabOrder = 4
Text = 'SUM'
OnChange = APA_FunctionChange
Items.Strings = (
'SUM'
'MAX'
'MIN'
'COUNT')
end
end
12.1.21 UNIT APA_KEYUNIT.PAS
unit APA_Keyunit;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
- 413 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Dialogs, Spin, StdCtrls, ExtCtrls;
type
TAPA_Insert_Key = class(TForm)
Bevel1: TBevel;
OKBtn: TButton;
CancelBtn: TButton;
Label1: TLabel;
Key_fieldname: TEdit;
Label2: TLabel;
APA_Field_type: TComboBox;
Label3: TLabel;
APA_Function: TComboBox;
procedure Key_fieldnameChange(Sender: TObject);
procedure OKBtnClick(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure APA_FunctionChange(Sender: TObject);
procedure APA_Field_typeChange(Sender: TObject);
private
{ Private-Deklarationen }
public
{ Public-Deklarationen }
end;
var
APA_Insert_Key: TAPA_Insert_Key;
implementation
{$R *.dfm}
procedure TAPA_Insert_Key.Key_fieldnameChange(Sender: TObject);
begin
OKBtn.Enabled:=true;
end;
procedure TAPA_Insert_Key.OKBtnClick(Sender: TObject);
var st:string;
begin
if (pos('//',Key_Fieldname.Text)<>0) then begin;
showmessage('Sting "//" is not allowed in Fieldname');
st:=Key_Fieldname.Text;
delete(st,pos('//',st),2);
Key_Fieldname.Text:=st;
end;
end;
procedure TAPA_Insert_Key.FormShow(Sender: TObject);
begin
Key_Fieldname.SetFocus;
end;
procedure TAPA_Insert_Key.APA_FunctionChange(Sender: TObject);
begin
OKBtn.Enabled:=true;
end;
procedure TAPA_Insert_Key.APA_Field_typeChange(Sender: TObject);
begin
OKBtn.Enabled:=true;
end;
end.
12.1.22 UNIT APA_OPTIONSUNIT.DFM
object APA_Options: TAPA_Options
Left = 223
Top = 134
Width = 454
- 414 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Height = 387
Caption = 'APA Options'
Color = clBtnFace
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -11
Font.Name = 'MS Sans Serif'
Font.Style = []
OldCreateOrder = False
Position = poScreenCenter
PixelsPerInch = 96
TextHeight = 13
object Panel1: TPanel
Left = 0
Top = 312
Width = 446
Height = 41
Align = alBottom
TabOrder = 0
object Button1: TButton
Left = 186
Top = 8
Width = 75
Height = 25
Cancel = True
Caption = 'Close'
Default = True
TabOrder = 0
OnClick = Button1Click
end
end
object PageControl1: TPageControl
Left = 0
Top = 0
Width = 446
Height = 312
ActivePage = APA_On_Start
Align = alClient
TabOrder = 1
object APA_On_Start: TTabSheet
Caption = 'On Start'
object APA_Load_Last_APA: TCheckBox
Left = 16
Top = 16
Width = 177
Height = 31
Caption = 'Load last APA'
Checked = True
State = cbChecked
TabOrder = 0
end
object APA_Remove_redundancy: TCheckBox
Left = 16
Top = 87
Width = 177
Height = 31
Caption = 'Remove Redundancy'
TabOrder = 1
end
object APA_Add_max_hier: TCheckBox
Left = 16
Top = 122
Width = 153
Height = 31
Caption = 'Add max hierarchy'
Checked = True
State = cbChecked
TabOrder = 2
end
object APA_Save_on_termination: TCheckBox
Left = 17
Top = 51
Width = 200
Height = 31
- 415 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Caption = 'Save APA on termination of program'
Checked = True
State = cbChecked
TabOrder = 3
end
object APA_ShowScreenheuristic: TCheckBox
Left = 16
Top = 158
Width = 265
Height = 31
Caption = 'Show process screen during heuristic execution'
Checked = True
State = cbChecked
TabOrder = 4
end
object APA_Show_Link_on_Desktop: TCheckBox
Left = 16
Top = 192
Width = 249
Height = 17
Caption = 'Show link on desktop'
Checked = True
State = cbChecked
TabOrder = 5
OnExit = APA_Show_Link_on_DesktopExit
end
end
object APA_Path_Settings: TTabSheet
Caption = 'Path Settings'
ImageIndex = 1
object Label1: TLabel
Left = 16
Top = 16
Width = 49
Height = 13
Caption = 'Savepath:'
end
object APA_Save_Path: TDirectoryListBox
Left = 16
Top = 48
Width = 417
Height = 129
ItemHeight = 16
TabOrder = 0
end
end
end
end
12.1.23 UNIT APA_OPTIONSUNIT.PAS
unit APA_Optionsunit;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, ExtCtrls, ComCtrls, DB, DBTables, FileCtrl;
type
TAPA_Options = class(TForm)
Panel1: TPanel;
Button1: TButton;
PageControl1: TPageControl;
APA_On_Start: TTabSheet;
APA_Load_Last_APA: TCheckBox;
APA_Remove_redundancy: TCheckBox;
APA_Add_max_hier: TCheckBox;
APA_Path_Settings: TTabSheet;
Label1: TLabel;
APA_Save_Path: TDirectoryListBox;
APA_Save_on_termination: TCheckBox;
- 416 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
APA_ShowScreenheuristic: TCheckBox;
APA_Show_Link_on_Desktop: TCheckBox;
procedure Button1Click(Sender: TObject);
procedure APA_Show_Link_on_DesktopExit(Sender: TObject);
private
{ Private-Deklarationen }
public
{ Public-Deklarationen }
end;
var
APA_Options: TAPA_Options;
implementation
uses APA_Applicationunit;
{$R *.dfm}
procedure TAPA_Options.Button1Click(Sender: TObject);
begin
Close;
end;
procedure TAPA_Options.APA_Show_Link_on_DesktopExit(Sender: TObject);
var fStreamladen,fStreamspeichern:TFileStream;
begin
if APA_Options.APA_Show_Link_on_Desktop.Checked=true then begin
if fileexists(APA_Application.shelldir.Path+'\APAWin.lnk')=false then begin
try
fStreamLaden:=TFileStream.Create('c:\APADIR\PROGRAM\APAWin.lnk',fmOpenRead);
try
fStreamSpeichern:=TFileStream.Create(APA_Application.shelldir.Path+'\APAWin.lnk',f
mCreate);
fStreamSpeichern.CopyFrom(fStreamLaden, fStreamLaden.Size);
finally
freeandnil(fStreamSpeichern);
end;
finally
freeandnil(fStreamLaden);
end;
end else begin
//Löschen
if fileexists(APA_Application.shelldir.Path+'\APAWin.lnk')=true then begin
try
deletefile(APA_Application.shelldir.Path+'\APAWin.lnk');
except
showmessage('Can not remove link from Desktop');
end;
end;
end;
end;
end;
end.
12.1.24 UNIT APA_PARAMETERUNIT.DFM
object APA_Parameter: TAPA_Parameter
Left = 280
Top = 188
BorderStyle = bsDialog
Caption = 'APA Parameter'
ClientHeight = 483
ClientWidth = 399
Color = clBtnFace
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
- 417 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Font.Height = -11
Font.Name = 'MS Sans Serif'
Font.Style = []
OldCreateOrder = False
Position = poScreenCenter
OnClose = FormClose
OnCreate = FormCreate
OnShow = FormShow
PixelsPerInch = 96
TextHeight = 13
object Panel1: TPanel
Left = 0
Top = 442
Width = 399
Height = 41
Align = alBottom
TabOrder = 0
object Button1: TButton
Left = 134
Top = 8
Width = 75
Height = 25
Caption = 'Close'
TabOrder = 0
OnClick = Button1Click
end
end
object APA_Parameter_Control: TPageControl
Left = 0
Top = 0
Width = 399
Height = 442
ActivePage = APA_Active_heuristicsheet
Align = alClient
TabOrder = 1
object APA_Active_heuristicsheet: TTabSheet
Caption = 'Heuristic && Algorithms parameters'
object GroupBox3: TGroupBox
Left = 0
Top = 0
Width = 391
Height = 161
Align = alTop
Caption = 'Thomas Achs heuristic parameters'
TabOrder = 0
object Label1: TLabel
Left = 24
Top = 24
Width = 128
Height = 13
Caption = 'New Sets on each iteration'
end
object Label2: TLabel
Left = 24
Top = 72
Width = 116
Height = 13
Caption = 'Count of Sets calculated'
end
object APA_Thomas_newsetsoneachiteration: TMaskEdit
Left = 24
Top = 40
Width = 33
Height = 21
EditMask = '0##;0; '
MaxLength = 3
TabOrder = 0
OnExit = APA_Thomas_newsetsoneachiterationExit
end
object APA_Thomas_countofsets: TMaskEdit
Left = 24
Top = 88
Width = 39
Height = 21
- 418 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
EditMask = '0###;0; '
MaxLength = 4
TabOrder = 1
OnExit = APA_Thomas_countofsetsExit
end
end
end
object Thomas_Achs_heuristic: TTabSheet
Caption = 'Cost function parameters'
object tomstorelabel: TLabel
Left = 38
Top = 318
Width = 139
Height = 13
Caption = 'Storage importantance: 25 % '
end
object tomtimelabel: TLabel
Left = 201
Top = 318
Width = 122
Height = 13
Alignment = taRightJustify
Caption = 'Time importantance: 75 %'
end
object Label9: TLabel
Left = 144
Top = 264
Width = 81
Height = 20
Caption = 'Importance'
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -16
Font.Name = 'MS Sans Serif'
Font.Style = []
ParentFont = False
end
object tommatcosts: TLabel
Left = 42
Top = 396
Width = 127
Height = 13
Caption = 'Materialisation costs: 25 % '
end
object tomquerycosts: TLabel
Left = 242
Top = 396
Width = 85
Height = 13
Alignment = taRightJustify
Caption = 'Query costs: 75 %'
end
object Label10: TLabel
Left = 159
Top = 342
Width = 50
Height = 20
Caption = 'Weight'
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -16
Font.Name = 'MS Sans Serif'
Font.Style = []
ParentFont = False
end
object APA_Thomas_Importance: TTrackBar
Left = 41
Top = 286
Width = 281
Height = 25
Hint = 'Select the weight of '
Max = 100
ParentShowHint = False
Frequency = 5
- 419 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Position = 10
ShowHint = True
TabOrder = 0
TickMarks = tmBoth
OnChange = APA_Thomas_ImportanceChange
end
object APA_Thomas_Query_Importance: TTrackBar
Left = 44
Top = 366
Width = 281
Height = 25
Hint = 'Select the weight of '
Max = 100
ParentShowHint = False
Frequency = 5
Position = 10
ShowHint = True
TabOrder = 1
TickMarks = tmBoth
OnChange = APA_Thomas_Query_ImportanceChange
end
object GroupBox4: TGroupBox
Left = 0
Top = 161
Width = 391
Height = 88
Align = alTop
Caption = 'Sizeoriented Parameters'
TabOrder = 2
object Label13: TLabel
Left = 52
Top = 19
Width = 158
Height = 26
Alignment = taRightJustify
Caption = 'Average size in bytes per tupel in BFT in space units:'
WordWrap = True
end
object Label14: TLabel
Left = 50
Top = 47
Width = 160
Height = 26
Alignment = taRightJustify
Caption =
'Max available storage space for Materialized Cubes in space unit' +
's:'
WordWrap = True
end
object APA_Thomas_avsizeoftupel: TMaskEdit
Left = 219
Top = 22
Width = 144
Height = 21
EditMask = '0###########;0; '
MaxLength = 12
TabOrder = 0
OnChange = APA_Thomas_timemaxChange
OnExit = APA_Thomas_avsizeoftupelExit
end
object APA_Thomas_spacemax: TMaskEdit
Left = 219
Top = 50
Width = 144
Height = 21
EditMask = '0#####################;0; '
MaxLength = 22
TabOrder = 1
OnChange = APA_Thomas_timemaxChange
OnExit = APA_Thomas_spacemaxExit
end
end
object GroupBox5: TGroupBox
Left = 0
- 420 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Top = 0
Width = 391
Height = 161
Align = alTop
Caption = 'Timeoriented Parameters'
TabOrder = 3
object Label12: TLabel
Left = 14
Top = 49
Width = 196
Height = 13
Alignment = taRightJustify
Caption = 'Average time for IO per tupel in time units:'
end
object Label15: TLabel
Left = 50
Top = 94
Width = 160
Height = 26
Alignment = taRightJustify
Caption = 'Max available time in time units to Build Materialized Cubes :'
WordWrap = True
end
object Label16: TLabel
Left = 43
Top = 14
Width = 167
Height = 26
Alignment = taRightJustify
Caption =
'Average time to store a tupel (Build materialized views) in time' +
' units:'
WordWrap = True
end
object Label3: TLabel
Left = 57
Top = 124
Width = 157
Height = 26
Alignment = taRightJustify
Caption = 'Maximal average time to query in time units:'
WordWrap = True
end
object Label4: TLabel
Left = 7
Top = 76
Width = 204
Height = 13
Alignment = taRightJustify
Caption = 'Average time of CPU per tupel in time units:'
end
object APA_Thomas_timestore: TMaskEdit
Left = 218
Top = 17
Width = 158
Height = 21
TabOrder = 0
Text = '2'
OnChange = APA_Thomas_timemaxChange
OnExit = APA_Thomas_timestoreExit
end
object APA_Thomas_timeio: TMaskEdit
Left = 218
Top = 45
Width = 158
Height = 21
TabOrder = 1
Text = '2'
OnChange = APA_Thomas_timemaxChange
OnExit = APA_Thomas_timeioExit
end
object APA_Thomas_timemax: TMaskEdit
Left = 218
Top = 100
- 421 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Width = 155
Height = 21
EditMask = '0###########;0; '
MaxLength = 12
TabOrder = 3
OnChange = APA_Thomas_timemaxChange
OnExit = APA_Thomas_timemaxExit
end
object APA_Thomas_querytimemax: TMaskEdit
Left = 218
Top = 127
Width = 157
Height = 21
TabOrder = 4
Text = '20'
OnChange = APA_Thomas_timemaxChange
OnExit = APA_Thomas_querytimemaxExit
end
object APA_Thomas_timecpu: TMaskEdit
Left = 218
Top = 73
Width = 151
Height = 21
TabOrder = 2
OnChange = APA_Thomas_timemaxChange
OnExit = APA_Thomas_timecpuExit
end
end
end
object Values_of_Cubes: TTabSheet
Caption = 'Degrees of requirements'
object Panel2: TPanel
Left = 0
Top = 0
Width = 391
Height = 137
Align = alTop
TabOrder = 0
object Label19: TLabel
Left = 8
Top = 8
Width = 101
Height = 13
Caption = 'Description of degree'
end
object Label21: TLabel
Left = 8
Top = 48
Width = 77
Height = 13
Caption = 'Count of queries'
end
object APA_Description_of_degree: TEdit
Left = 8
Top = 24
Width = 201
Height = 21
Enabled = False
TabOrder = 0
end
object Panel3: TPanel
Left = 1
Top = 96
Width = 389
Height = 40
Align = alBottom
TabOrder = 2
object APA_Degree_Insert: TButton
Left = 21
Top = 8
Width = 55
Height = 25
Caption = 'Insert'
TabOrder = 0
- 422 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
OnClick = APA_Degree_InsertClick
end
object APA_Degree_Edit: TButton
Left = 85
Top = 8
Width = 55
Height = 25
Caption = 'Edit'
TabOrder = 1
OnClick = APA_Degree_EditClick
end
object APA_Degree_Save: TButton
Left = 149
Top = 8
Width = 55
Height = 25
Caption = 'Save'
Enabled = False
TabOrder = 2
OnClick = APA_Degree_SaveClick
end
object APA_Degree_Delete: TButton
Left = 213
Top = 8
Width = 55
Height = 25
Caption = 'Delete'
TabOrder = 3
OnClick = APA_Degree_DeleteClick
end
object APA_Degree_Abort: TButton
Left = 277
Top = 7
Width = 55
Height = 25
Caption = 'Abort'
Enabled = False
TabOrder = 4
OnClick = APA_Degree_AbortClick
end
end
object APA_Count_of_Queries: TMaskEdit
Left = 9
Top = 64
Width = 136
Height = 21
Enabled = False
EditMask = '0###############;0; '
MaxLength = 16
TabOrder = 1
OnChange = APA_Thomas_timemaxChange
OnExit = APA_Count_of_QueriesExit
end
end
object Panel4: TPanel
Left = 0
Top = 137
Width = 42
Height = 277
Align = alLeft
TabOrder = 1
object APA_Degree_up: TBitBtn
Left = 5
Top = 4
Width = 28
Height = 25
Caption = 'UP'
TabOrder = 0
OnClick = APA_Degree_upClick
Layout = blGlyphTop
end
object APA_Degree_Down: TBitBtn
Left = 0
Top = 36
- 423 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Width = 39
Height = 25
Caption = 'DOWN'
TabOrder = 1
OnClick = APA_Degree_DownClick
Layout = blGlyphTop
end
end
object GroupBox1: TGroupBox
Left = 258
Top = 137
Width = 133
Height = 277
Align = alRight
Caption = 'Count of queries'
TabOrder = 2
object APA_Degreecounts: TListBox
Left = 2
Top = 15
Width = 129
Height = 260
Align = alClient
ItemHeight = 13
Items.Strings = (
'10000'
'1000'
'1')
TabOrder = 0
OnClick = APA_DegreecountsClick
end
end
object GroupBox2: TGroupBox
Left = 42
Top = 137
Width = 216
Height = 277
Align = alClient
Caption = 'Description of degree'
TabOrder = 3
object APA_Degrees: TListBox
Left = 2
Top = 15
Width = 212
Height = 260
Align = alClient
ItemHeight = 13
Items.Strings = (
'High Importance'
'Normal Importance'
'Unimportant')
TabOrder = 0
OnClick = APA_DegreesClick
end
end
end
object APA_Colors_of_Degrees: TTabSheet
Caption = 'Colors of Requirements'
ImageIndex = 4
object Panel5: TPanel
Left = 0
Top = 0
Width = 391
Height = 41
Align = alTop
TabOrder = 0
object APA_Changecolorbutton: TButton
Left = 8
Top = 8
Width = 121
Height = 25
Caption = 'Change color'
TabOrder = 0
OnClick = APA_ChangecolorbuttonClick
end
- 424 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end
object Colorsgrid: TDrawGrid
Left = 0
Top = 41
Width = 391
Height = 373
Align = alClient
ColCount = 1
DefaultColWidth = 300
FixedCols = 0
RowCount = 15
FixedRows = 0
Options = [goFixedVertLine, goFixedHorzLine, goVertLine, goHorzLine,
goRangeSelect, goRowSelect]
TabOrder = 1
OnDrawCell = ColorsgridDrawCell
RowHeights = (
24
24
24
24
24
24
24
24
24
24
24
24
24
24
24)
end
end
end
object ColorDialog: TColorDialog
Left = 308
Top = 280
end
end
12.1.25 UNIT APA_PARAMETERUNIT.PAS
unit APA_Parameterunit;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, ComCtrls, StdCtrls, ExtCtrls, Buttons, Grids, Mask;
type
TAPA_Parameter = class(TForm)
Panel1: TPanel;
Button1: TButton;
APA_Parameter_Control: TPageControl;
Values_of_Cubes: TTabSheet;
Panel2: TPanel;
Label19: TLabel;
APA_Description_of_degree: TEdit;
Panel3: TPanel;
APA_Degree_Insert: TButton;
APA_Degree_Edit: TButton;
APA_Degree_Save: TButton;
APA_Degree_Delete: TButton;
Label21: TLabel;
Panel4: TPanel;
APA_Degree_up: TBitBtn;
APA_Degree_Down: TBitBtn;
APA_Active_heuristicsheet: TTabSheet;
Thomas_Achs_heuristic: TTabSheet;
- 425 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
GroupBox1: TGroupBox;
APA_Degreecounts: TListBox;
GroupBox2: TGroupBox;
APA_Degrees: TListBox;
APA_Degree_Abort: TButton;
APA_Colors_of_Degrees: TTabSheet;
ColorDialog: TColorDialog;
Panel5: TPanel;
APA_Changecolorbutton: TButton;
Colorsgrid: TDrawGrid;
tomstorelabel: TLabel;
tomtimelabel: TLabel;
Label9: TLabel;
APA_Thomas_Importance: TTrackBar;
tommatcosts: TLabel;
tomquerycosts: TLabel;
Label10: TLabel;
APA_Thomas_Query_Importance: TTrackBar;
GroupBox3: TGroupBox;
APA_Thomas_newsetsoneachiteration: TMaskEdit;
Label1: TLabel;
APA_Thomas_countofsets: TMaskEdit;
Label2: TLabel;
APA_Count_of_Queries: TMaskEdit;
GroupBox4: TGroupBox;
Label13: TLabel;
Label14: TLabel;
APA_Thomas_avsizeoftupel: TMaskEdit;
APA_Thomas_spacemax: TMaskEdit;
GroupBox5: TGroupBox;
Label12: TLabel;
Label15: TLabel;
Label16: TLabel;
Label3: TLabel;
APA_Thomas_timestore: TMaskEdit;
APA_Thomas_timeio: TMaskEdit;
APA_Thomas_timemax: TMaskEdit;
APA_Thomas_querytimemax: TMaskEdit;
Label4: TLabel;
APA_Thomas_timecpu: TMaskEdit;
procedure Button1Click(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure APA_Degree_InsertClick(Sender: TObject);
procedure APA_DegreesClick(Sender: TObject);
procedure APA_DegreecountsClick(Sender: TObject);
procedure APA_Degree_SaveClick(Sender: TObject);
procedure APA_Degree_EditClick(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
procedure APA_Degree_AbortClick(Sender: TObject);
procedure APA_Degree_DeleteClick(Sender: TObject);
procedure APA_Degree_upClick(Sender: TObject);
procedure APA_Degree_DownClick(Sender: TObject);
procedure ColorBox1Exit(Sender: TObject);
procedure ColorsgridDrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
procedure APA_ChangecolorbuttonClick(Sender: TObject);
procedure Colorsgrid2DrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
procedure APA_Thomas_ImportanceChange(Sender: TObject);
procedure APA_Thomas_Query_ImportanceChange(Sender: TObject);
procedure APA_Thomas_timemaxChange(Sender: TObject);
procedure APA_Thomas_newsetsoneachiterationExit(Sender: TObject);
procedure APA_Thomas_countofsetsExit(Sender: TObject);
procedure APA_Thomas_timestoreExit(Sender: TObject);
procedure APA_Thomas_timeioExit(Sender: TObject);
procedure APA_Thomas_timecpuExit(Sender: TObject);
procedure APA_Thomas_timemaxExit(Sender: TObject);
procedure APA_Thomas_querytimemaxExit(Sender: TObject);
procedure APA_Thomas_avsizeoftupelExit(Sender: TObject);
procedure APA_Thomas_spacemaxExit(Sender: TObject);
procedure APA_Count_of_QueriesExit(Sender: TObject);
private
{ Private-Deklarationen }
- 426 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
public
{ Public-Deklarationen }
end;
var
APA_Parameter: TAPA_Parameter;
DegreeColors:array[0..14] of TColor;
Othercolors:array[0..14] of TColor;
implementation
uses APA_Applicationunit, APA_Gridunit, APA_Selectionunit;
{$R *.dfm}
var degreeedit:longint=-2;
procedure TAPA_Parameter.Button1Click(Sender: TObject);
begin
Close;
end;
procedure TAPA_Parameter.FormShow(Sender: TObject);
begin
APA_Thomas_ImportanceChange(self);
APA_Thomas_Query_ImportanceChange(self);
end;
procedure TAPA_Parameter.FormCreate(Sender: TObject);
begin
APA_Parameter_Control.ActivePageIndex:=0;
APA_Thomas_Importance.Position:=75;
APA_Thomas_Query_Importance.Position:=75;
//Standardfarben für Requirements festlegen
DegreeColors[0]:=clBlue;
DegreeColors[1]:=clMaroon;
DegreeColors[2]:=clGreen;
DegreeColors[3]:=clOlive;
DegreeColors[4]:=clNavy;
DegreeColors[5]:=clPurple;
DegreeColors[6]:=clTeal;
DegreeColors[7]:=clGray;
DegreeColors[8]:=clRed;
DegreeColors[9]:=clFuchsia;
DegreeColors[10]:=clAqua;
DegreeColors[11]:=clLtGray;
DegreeColors[12]:=clCream;
DegreeColors[13]:=clSkyBlue;
DegreeColors[14]:=clMoneyGreen;
OtherColors[0]:=clYellow; //Farbe für Rednundanzfrei
OtherColors[1]:=clRed; //Farbe für materalisiert
OtherColors[2]:=clBlack; //Farbe für Derivate
end;
procedure TAPA_Parameter.APA_Degree_InsertClick(Sender: TObject);
begin
if APA_Degrees.Items.Count<15 then begin
APA_Description_of_degree.Enabled:=true;
APA_Count_of_Queries.Enabled:=true;
APA_Degree_Insert.Enabled:=false;
APA_Degree_Edit.Enabled:=false;
APA_Degree_Save.Enabled:=true;
APA_Degree_Delete.Enabled:=false;
APA_Degree_Abort.Enabled:=true;
APA_Description_of_degree.Text:='';
APA_Count_of_Queries.Text:='1';
APA_Description_of_degree.SetFocus;
- 427 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
mustsave:=true;
end else showmessage('Maxium Count of Entrys of 15 reached');
end;
procedure TAPA_Parameter.APA_DegreesClick(Sender: TObject);
begin
APA_Degreecounts.ItemIndex:=APA_Degrees.ItemIndex;
end;
procedure TAPA_Parameter.APA_DegreecountsClick(Sender: TObject);
begin
APA_Degrees.ItemIndex:=APA_Degreecounts.ItemIndex;
end;
procedure TAPA_Parameter.APA_Degree_SaveClick(Sender: TObject);
begin
mustsave:=true;
APA_Description_of_degree.Enabled:=false;
APA_Count_of_Queries.Enabled:=false;
APA_Degree_Insert.Enabled:=true;
APA_Degree_Edit.Enabled:=true;
APA_Degree_Save.Enabled:=false;
APA_Degree_Delete.Enabled:=true;
APA_Degree_Abort.Enabled:=false;
if APA_Degree_Edit.tag=0 then begin
APA_Degrees.Items.Add(APA_Description_of_degree.Text);
APA_Degreecounts.Items.Add(APA_Count_of_Queries.Text);
end else begin
APA_Degrees.Items[APA_Degrees.itemindex]:=APA_Description_of_degree.Text;
APA_Degreecounts.Items[APA_Degreecounts.ItemIndex]:=APA_Count_of_Queries.Text;
end;
APA_Degree_Edit.Tag:=0;
end;
procedure TAPA_Parameter.APA_Degree_EditClick(Sender: TObject);
begin
if APA_Degrees.ItemIndex<>-1 then begin
APA_Description_of_degree.Enabled:=true;
APA_Count_of_Queries.Enabled:=true;
APA_Degree_Insert.Enabled:=false;
APA_Degree_Edit.Enabled:=false;
APA_Degree_Save.Enabled:=true;
APA_Degree_Delete.Enabled:=false;
APA_Degree_Abort.Enabled:=true;
APA_Description_of_degree.Text:= APA_Degrees.Items[APA_Degrees.itemindex];
APA_Count_of_Queries.Text:= APA_Degreecounts.Items[APA_Degreecounts.itemindex];
APA_Description_of_degree.SetFocus;
APA_Degree_Edit.Tag:=1;//Edit Mode setzen
mustsave:=true;
end else showmessage('No Entry selected');
end;
procedure TAPA_Parameter.FormClose(Sender: TObject;
var Action: TCloseAction);
begin
if APA_Degree_Edit.Tag=1 then begin
if messagedlg('Do you want to save your changes?',mtconfirmation,[mbyes,mbno],0)=mryes
then APA_Degree_Save.Click else APA_Degree_Abort.Click;
end;
end;
procedure TAPA_Parameter.APA_Degree_AbortClick(Sender: TObject);
begin
mustsave:=true;
APA_Description_of_degree.Enabled:=false;
APA_Count_of_Queries.Enabled:=false;
APA_Degree_Insert.Enabled:=true;
- 428 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
APA_Degree_Edit.Enabled:=true;
APA_Degree_Save.Enabled:=false;
APA_Degree_Delete.Enabled:=true;
APA_Degree_Abort.Enabled:=false;
APA_Degree_Edit.Tag:=0;
end;
procedure TAPA_Parameter.APA_Degree_DeleteClick(Sender: TObject);
var ok:boolean;
var aktzeile,aktspalte:longint;
begin
if APA_Degrees.ItemIndex<>-1 then begin
ok:=true;
for aktspalte:=0 to anzspalten-1 do begin
for aktzeile:=0 to anzzeilen-1 do begin
if APA[aktspalte,aktzeile].interessant=true then begin
if APA[aktspalte,aktzeile].gewichtlevel=APA_Degrees.ItemIndex then begin
ok:=false;
end;
end;
end;
end;
if ok=false then showmessage('Degree is used in APA. Could not delete degree!');
if ok=true then begin
for aktzeile:= 0 to APA_Selection_Screen.Listeint.items.count-1 do begin
if copy(APA_Selection_Screen.Listeint.items[aktzeile],1,3)='Req' then begin
if
APA_Degrees.ItemIndex=strtoint(copy(APA_Selection_Screen.Listeint.items[aktzeile],
5,100)) then begin
ok:=false;
end;
end;
end;
if ok=false then showmessage('Degree is used in Selection Screen. Could not delete
degree!');
end;
if ok=true then begin
APA_Degreecounts.Items.Delete(APA_Degrees.ItemIndex);
APA_Degrees.Items.Delete(APA_Degrees.ItemIndex);
mustsave:=true;
end;
end else showmessage('No Entry selected');
end;
procedure TAPA_Parameter.APA_Degree_upClick(Sender: TObject);
var ok:boolean;
var aktspalte,aktzeile:longint;
begin
if (APA_Degrees.ItemIndex<>-1) then begin
if (APA_Degrees.ItemIndex<>0) then begin
ok:=true;
for aktspalte:=0 to anzspalten-1 do begin
for aktzeile:=0 to anzzeilen-1 do begin
if APA[aktspalte,aktzeile].interessant=true then begin
if (APA[aktspalte,aktzeile].gewichtlevel=APA_Degrees.ItemIndex)or
(APA[aktspalte,aktzeile].gewichtlevel=APA_Degrees.ItemIndex-1) then begin
ok:=false;
end;
end;
- 429 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end;
end;
if ok=false then showmessage('Degree or upper degree is used in APA. Could not move
degree!');
if ok=true then begin
for aktzeile:= 0 to APA_Selection_Screen.Listeint.items.count-1 do begin
if copy(APA_Selection_Screen.Listeint.items[aktzeile],1,3)='Req' then begin
if
(APA_Degrees.ItemIndex=strtoint(copy(APA_Selection_Screen.Listeint.items[aktzeile]
,5,100))) or
(APA_Degrees.ItemIndex1=strtoint(copy(APA_Selection_Screen.Listeint.items[aktzeile],5,100)))then begin
ok:=false;
end;
end;
end;
if ok=false then showmessage('Degree or upper degree is used in Selection Screen. Could
not move degree!');
end;
if ok=true then begin
APA_Degrees.Items.Move(APA_Degrees.ItemIndex,APA_Degrees.ItemIndex-1);
mustsave:=true;
end;
end else showmessage('Top Entry selected');
end else showmessage('No Entry selected');
end;
procedure TAPA_Parameter.APA_Degree_DownClick(Sender: TObject);
var ok:boolean;
var aktspalte,aktzeile:longint;
begin
if (APA_Degrees.ItemIndex<>-1) then begin
if (APA_Degrees.ItemIndex<>APA_Degrees.Items.Count-1) then begin
ok:=true;
for aktspalte:=0 to anzspalten-1 do begin
for aktzeile:=0 to anzzeilen-1 do begin
if APA[aktspalte,aktzeile].interessant=true then begin
if (APA[aktspalte,aktzeile].gewichtlevel=APA_Degrees.ItemIndex)or
(APA[aktspalte,aktzeile].gewichtlevel=APA_Degrees.ItemIndex+1) then begin
ok:=false;
end;
end;
end;
end;
if ok=false then showmessage('Degree oder lower degree is used in APA. Could not move
degree!');
if ok=true then begin
for aktzeile:= 0 to APA_Selection_Screen.Listeint.items.count-1 do begin
if copy(APA_Selection_Screen.Listeint.items[aktzeile],1,3)='Req' then begin
if
(APA_Degrees.ItemIndex=strtoint(copy(APA_Selection_Screen.Listeint.items[aktzeile]
,5,100)))or
(APA_Degrees.ItemIndex+1=strtoint(copy(APA_Selection_Screen.Listeint.items[aktzeil
e],5,100))) then begin
ok:=false;
end;
end;
end;
if ok=false then showmessage('Degree or lower degree is used in Selection Screen. Could
not move degree!');
end;
if ok=true then begin
- 430 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
mustsave:=true;
APA_Degrees.Items.Move(APA_Degrees.ItemIndex,APA_Degrees.ItemIndex+1);
end;
end else showmessage('Last Entry selected');
end else showmessage('No Entry selected');
end;
procedure TAPA_Parameter.ColorBox1Exit(Sender: TObject);
begin
Colordialog.Execute;
end;
procedure TAPA_Parameter.ColorsgridDrawCell(Sender: TObject; ACol,
ARow: Integer; Rect: TRect; State: TGridDrawState);
begin
Colorsgrid.Canvas.Brush.Color:=DegreeColors[Arow];
Colorsgrid.Canvas.FillRect(Rect);
if Arow<APA_Degrees.items.count then begin
Colorsgrid.Canvas.TextOut(round((Rect.left+Rect.right)/2)round(Colorsgrid.Canvas.TextWidth(APA_Degrees.items[Arow])/2),
round((Rect.top+Rect.Bottom)/2)round(Colorsgrid.Canvas.TextHeight(APA_Degrees.items[Arow])/2),APA_Degrees.items[A
row])
end else
Colorsgrid.Canvas.TextOut(round((Rect.left+Rect.right)/2)round(Colorsgrid.Canvas.TextWidth('Entry '+inttostr(Arow))/2),
round((Rect.top+Rect.Bottom)/2)-round(Colorsgrid.Canvas.TextHeight('Entry
'+inttostr(Arow))/2),'Entry '+inttostr(Arow));
end;
procedure TAPA_Parameter.APA_ChangecolorbuttonClick(Sender: TObject);
begin
mustsave:=true;
if Colordialog.Execute then begin
DegreeColors[Colorsgrid.Row]:=Colordialog.Color;
Colorsgrid.Repaint;
end;
end;
procedure TAPA_Parameter.Colorsgrid2DrawCell(Sender: TObject; ACol,
ARow: Integer; Rect: TRect; State: TGridDrawState);
begin
Colorsgrid.Canvas.Brush.Color:=DegreeColors[Arow];
Colorsgrid.Canvas.FillRect(Rect);
if Arow<APA_Degrees.items.count then begin
Colorsgrid.Canvas.TextOut(round((Rect.left+Rect.right)/2)round(Colorsgrid.Canvas.TextWidth(APA_Degrees.items[Arow])/2),
round((Rect.top+Rect.Bottom)/2)round(Colorsgrid.Canvas.TextHeight(APA_Degrees.items[Arow])/2),APA_Degrees.items[A
row])
end else
Colorsgrid.Canvas.TextOut(round((Rect.left+Rect.right)/2)round(Colorsgrid.Canvas.TextWidth('Entry '+inttostr(Arow))/2),
round((Rect.top+Rect.Bottom)/2)-round(Colorsgrid.Canvas.TextHeight('Entry
'+inttostr(Arow))/2),'Entry '+inttostr(Arow));
end;
procedure TAPA_Parameter.APA_Thomas_ImportanceChange(Sender: TObject);
begin
mustsave:=true;
tomstorelabel.Caption:='Storage importance: '+
inttostr(100-APA_Thomas_Importance.Position)+' %';
tomtimelabel.Caption:='Time importance: '+
inttostr(APA_Thomas_Importance.Position)+' %';
end;
- 431 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
procedure TAPA_Parameter.APA_Thomas_Query_ImportanceChange(
Sender: TObject);
begin
mustsave:=true;
tommatcosts.Caption:='Materialisation costs: '+
inttostr(100-APA_Thomas_Query_Importance.Position)+' %';
tomquerycosts.Caption:='Query costs: '+
inttostr(APA_Thomas_Query_Importance.Position)+' %';
end;
procedure TAPA_Parameter.APA_Thomas_timemaxChange(Sender: TObject);
begin
mustsave:=true;
end;
procedure TAPA_Parameter.APA_Thomas_newsetsoneachiterationExit(
Sender: TObject);
begin
APA_Thomas_newsetsoneachiteration.Text:=
trim (APA_Thomas_newsetsoneachiteration.Text);
try
strtoint(APA_Thomas_newsetsoneachiteration.Text);
except
APA_Thomas_newsetsoneachiteration.Text:='2';
end;
end;
procedure TAPA_Parameter.APA_Thomas_countofsetsExit(Sender: TObject);
begin
APA_Thomas_countofsets.Text:=
trim(APA_Thomas_countofsets.Text);
try
strtoint(APA_Thomas_countofsets.Text);
except
APA_Thomas_countofsets.Text:='10';
end;
end;
procedure TAPA_Parameter.APA_Thomas_timestoreExit(Sender: TObject);
begin
APA_Thomas_timestore.Text:=
trim(APA_Thomas_timestore.Text);
try
strtofloat(APA_Thomas_timestore.Text);
except
APA_Thomas_timestore.Text:='2';
end;
end;
procedure TAPA_Parameter.APA_Thomas_timeioExit(Sender: TObject);
begin
APA_Thomas_timeio.Text:=
trim(APA_Thomas_timeio.Text);
try
strtofloat(APA_Thomas_timeio.Text);
except
APA_Thomas_timeio.Text:='2';
end;
end;
procedure TAPA_Parameter.APA_Thomas_timecpuExit(Sender: TObject);
begin
APA_Thomas_timecpu.Text:=
- 432 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
trim(APA_Thomas_timecpu.Text);
try
strtofloat(APA_Thomas_timecpu.Text);
except
APA_Thomas_timecpu.Text:='0,002';
end;
end;
procedure TAPA_Parameter.APA_Thomas_timemaxExit(Sender: TObject);
begin
APA_Thomas_timemax.Text:=trim(APA_Thomas_timemax.Text);
try
strtofloat(APA_Thomas_timemax.Text);
except
APA_Thomas_timemax.Text:='200000';
end;
end;
procedure TAPA_Parameter.APA_Thomas_querytimemaxExit(Sender: TObject);
begin
APA_Thomas_querytimemax.Text:=trim(APA_Thomas_querytimemax.Text);
try
strtofloat(APA_Thomas_querytimemax.Text);
except
APA_Thomas_querytimemax.Text:='20';
end;
end;
procedure TAPA_Parameter.APA_Thomas_avsizeoftupelExit(Sender: TObject);
begin
APA_Thomas_avsizeoftupel.Text:=trim(APA_Thomas_avsizeoftupel.Text);
try
strtofloat(APA_Thomas_avsizeoftupel.Text);
except
APA_Thomas_avsizeoftupel.Text:='32';
end;
end;
procedure TAPA_Parameter.APA_Thomas_spacemaxExit(Sender: TObject);
begin
APA_Thomas_spacemax.Text:=trim(APA_Thomas_spacemax.Text);
try
strtofloat(APA_Thomas_spacemax.Text);
except
APA_Thomas_spacemax.Text:='1000000';
end;
end;
procedure TAPA_Parameter.APA_Count_of_QueriesExit(Sender: TObject);
begin
APA_Count_of_Queries.Text:=trim(APA_Count_of_Queries.text);
try
strtoint(APA_Count_of_Queries.Text);
except
APA_Count_of_Queries.Text:='1';
end;
end;
end.
- 433 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
12.1.26 UNIT APA_PROCESSUNIT.DFM
object APA_Show_Process: TAPA_Show_Process
Left = 266
Top = 233
BorderStyle = bsDialog
Caption = 'Show Process'
ClientHeight = 278
ClientWidth = 322
Color = clBtnFace
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -11
Font.Name = 'MS Sans Serif'
Font.Style = []
FormStyle = fsStayOnTop
OldCreateOrder = False
Position = poScreenCenter
OnClose = FormClose
OnShow = FormShow
PixelsPerInch = 96
TextHeight = 13
object Panel1: TPanel
Left = 0
Top = 237
Width = 322
Height = 41
Align = alBottom
TabOrder = 0
object ButtonCancel: TButton
Left = 36
Top = 8
Width = 75
Height = 25
Caption = 'Abort'
TabOrder = 0
OnClick = ButtonCancelClick
end
object ButtonPause: TButton
Left = 184
Top = 8
Width = 75
Height = 25
Caption = 'Pause'
TabOrder = 1
OnClick = ButtonPauseClick
end
end
object GroupBox1: TGroupBox
Left = 0
Top = 0
Width = 322
Height = 237
Align = alClient
Caption = 'Protocoll'
TabOrder = 1
OnDblClick = GroupBox1DblClick
object APA_Protocoll: TListBox
Left = 2
Top = 15
Width = 318
Height = 220
Align = alClient
ItemHeight = 13
TabOrder = 0
end
end
object Ausschalten: TTimer
Enabled = False
Interval = 5000
OnTimer = AusschaltenTimer
Left = 128
Top = 112
- 434 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end
object secretMenu1: TPopupMenu
Left = 176
Top = 64
object up1: TMenuItem
Caption = 'up'
OnClick = up1Click
end
object down1: TMenuItem
Caption = 'down'
OnClick = down1Click
end
object ShowProtokoll1: TMenuItem
Caption = 'Show Protokoll'
OnClick = ShowProtokoll1Click
end
object HideProtokoll1: TMenuItem
Caption = 'Hide Protokoll'
OnClick = HideProtokoll1Click
end
object Expertmode1: TMenuItem
AutoCheck = True
Caption = 'Expertmode'
end
end
end
12.1.27 UNIT APA_PROCESSUNIT.PAS
unit APA_Processunit;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, ExtCtrls, Menus;
type
TAPA_Show_Process = class(TForm)
Panel1: TPanel;
ButtonCancel: TButton;
GroupBox1: TGroupBox;
APA_Protocoll: TListBox;
ButtonPause: TButton;
Ausschalten: TTimer;
secretMenu1: TPopupMenu;
up1: TMenuItem;
down1: TMenuItem;
ShowProtokoll1: TMenuItem;
HideProtokoll1: TMenuItem;
Expertmode1: TMenuItem;
procedure ausgabe(Ausgabe:string);
procedure FormShow(Sender: TObject);
procedure ButtonCancelClick(Sender: TObject);
procedure ButtonPauseClick(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
procedure AusschaltenTimer(Sender: TObject);
procedure GroupBox1DblClick(Sender: TObject);
procedure up1Click(Sender: TObject);
procedure down1Click(Sender: TObject);
procedure ShowProtokoll1Click(Sender: TObject);
procedure HideProtokoll1Click(Sender: TObject);
private
{ Private-Deklarationen }
public
{ Public-Deklarationen }
end;
var
APA_Show_Process: TAPA_Show_Process;
stop, break:boolean;
implementation
- 435 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
uses APA_Dialogunit;
{$R *.dfm}
var showprotokoll:boolean=true;
procedure TAPA_Show_Process.ausgabe(Ausgabe:string);
begin;
if showprotokoll=true then begin
APA_Show_Process.APA_Protocoll.Items.Add(Ausgabe);
APA_Show_Process.APA_Protocoll.ItemIndex:=APA_Show_Process.APA_Protocoll.Items.Cou
nt-1;
Application.ProcessMessages;
end;
end;
procedure TAPA_Show_Process.FormShow(Sender: TObject);
begin
stop:=false;
end;
procedure TAPA_Show_Process.ButtonCancelClick(Sender: TObject);
begin
stop:=true;
break:=false;
Ausschalten.Enabled:=false;
APA_Show_Process.ButtonPause.Visible:=true;
Close;
end;
procedure TAPA_Show_Process.ButtonPauseClick(Sender: TObject);
begin
if break=false then begin
break:=true;
ButtonPause.Caption:='Resume';
end else begin
break:=false;
ButtonPause.Caption:='Pause';
end;
end;
procedure TAPA_Show_Process.FormClose(Sender: TObject;
var Action: TCloseAction);
begin
Stop:=true;
break:=false;
showprotokoll:=true;
APA_Show_Process.ButtonCancel.Caption:='Abort';
end;
procedure TAPA_Show_Process.AusschaltenTimer(Sender: TObject);
begin
Ausschalten.Enabled:=false;
APA_Show_Process.ButtonPause.Visible:=true;
Close;
end;
procedure TAPA_Show_Process.GroupBox1DblClick(Sender: TObject);
begin
Groupbox1.PopupMenu:=secretMenu1;
end;
procedure TAPA_Show_Process.up1Click(Sender: TObject);
begin
APA_Dialog.APA_Text.Caption:='Are you sure?';
if APA_Dialog.showmodal=mryes then
Groupbox1.Tag:=1;
end;
procedure TAPA_Show_Process.down1Click(Sender: TObject);
begin
APA_Dialog.APA_Text.Caption:='Are you sure?';
- 436 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if APA_Dialog.showmodal=mryes then
Groupbox1.Tag:=-1;
end;
procedure TAPA_Show_Process.ShowProtokoll1Click(Sender: TObject);
begin
showprotokoll:=true;
end;
procedure TAPA_Show_Process.HideProtokoll1Click(Sender: TObject);
begin
showprotokoll:=false;
end;
end.
12.1.28 UNIT APA_SCREENUNIT.DFM
object APA_Screen: TAPA_Screen
Left = 308
Top = 209
BorderStyle = bsNone
Caption = 'APA_Screen'
ClientHeight = 182
ClientWidth = 233
Color = clWhite
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -11
Font.Name = 'MS Sans Serif'
Font.Style = []
FormStyle = fsStayOnTop
OldCreateOrder = False
Position = poScreenCenter
OnClick = FormClick
OnCreate = FormCreate
PixelsPerInch = 96
TextHeight = 13
object Shape1: TShape
Left = 0
Top = 0
Width = 233
Height = 182
Align = alClient
Pen.Color = clGreen
Pen.Width = 2
OnMouseDown = Shape2MouseDown
end
object Shape2: TShape
Left = 4
Top = 4
Width = 225
Height = 173
Pen.Color = clGreen
OnMouseDown = Shape2MouseDown
end
object Image1: TImage
Left = 69
Top = 32
Width = 95
Height = 90
AutoSize = True
Picture.Data = {
07544269746D6170F6250000424DF62500000000000036040000280000005F00
00005A0000000100080000000000C0210000120B0000120B0000000100000000
000000000000330000006600000099000000CC000000FF000000003300003333
. . .
. . .
D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7
D700D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7
D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7
- 437 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7D7
D700}
OnClick = Image1Click
end
object Label1: TLabel
Left = 19
Top = 8
Width = 195
Height = 23
Caption = 'APA Application'
Font.Charset = DEFAULT_CHARSET
Font.Color = clGreen
Font.Height = -21
Font.Name = 'Courier New'
Font.Style = [fsBold]
ParentFont = False
end
object Label2: TLabel
Left = 62
Top = 120
Width = 110
Height = 18
Caption = 'designed by'
Font.Charset = DEFAULT_CHARSET
Font.Color = clGreen
Font.Height = -16
Font.Name = 'Courier New'
Font.Style = [fsBold]
ParentFont = False
end
object Label3: TLabel
Left = 62
Top = 140
Width = 110
Height = 18
Caption = 'Thomas ACHS'
Font.Charset = DEFAULT_CHARSET
Font.Color = clGreen
Font.Height = -16
Font.Name = 'Courier New'
Font.Style = [fsBold]
ParentFont = False
end
object Label4: TLabel
Left = 69
Top = 161
Width = 100
Height = 10
Align = alCustom
Alignment = taCenter
Caption = ' Starting Program...'
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -9
Font.Name = 'Lucida Sans Typewriter'
Font.Style = []
ParentFont = False
end
object Timer1: TTimer
Interval = 100
OnTimer = Timer1Timer
Left = 32
Top = 48
end
end
12.1.29 UNIT APA_SCREENUNIT.PAS
unit APA_Screenunit;
interface
- 438 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, ExtCtrls, StdCtrls, DB, DBTables;
type
TAPA_Screen = class(TForm)
Image1: TImage;
Shape1: TShape;
Shape2: TShape;
Label1: TLabel;
Label2: TLabel;
Label3: TLabel;
Timer1: TTimer;
Label4: TLabel;
procedure FormClick(Sender: TObject);
procedure Image1Click(Sender: TObject);
procedure Shape2MouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
procedure Timer1Timer(Sender: TObject);
procedure FormCreate(Sender: TObject);
private
{ Private-Deklarationen }
public
{ Public-Deklarationen }
end;
var
APA_Screen: TAPA_Screen;
implementation
uses APA_Applicationunit;
{$R *.dfm}
var counter:longint=0;
procedure TAPA_Screen.FormClick(Sender: TObject);
begin
Counter:=100;
end;
procedure TAPA_Screen.Image1Click(Sender: TObject);
begin
Counter:=100;
end;
procedure TAPA_Screen.Shape2MouseDown(Sender: TObject;
Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
Counter:=100;
end;
procedure TAPA_Screen.Timer1Timer(Sender: TObject);
begin
counter:=counter+1;
if counter=10 then Label4.Caption:=' Loading Settings...';
if counter=25 then Label4.Caption:=' Ready to start...';
if counter>30 then begin;
Timer1.Enabled:=false;
APA_Screen.Hide;
APA_Application.showmodal;
Close;
end;
end;
procedure TAPA_Screen.FormCreate(Sender: TObject);
begin
CurrencyString:='';
ShortDateFormat:='dd.mm.yyyy';
LongDateFormat:='dd.mm.yyyy';
DateSeparator := '.';
ThousandSeparator:='.';
- 439 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
DecimalSeparator:=',';
CurrencyDecimals:=2;
ShortTimeFormat:='hh:nn';
LongTimeFormat:='hh:nn';
end;
end.
12.1.30 UNIT APA_SELECTIONUNIT.DFM
object APA_Selection_Screen: TAPA_Selection_Screen
Left = 100
Top = 115
Width = 760
Height = 551
Caption = 'APA Selection Screen'
Color = clBtnFace
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -11
Font.Name = 'MS Sans Serif'
Font.Style = []
OldCreateOrder = False
OnShow = FormShow
PixelsPerInch = 96
TextHeight = 13
object Panel2: TPanel
Left = 0
Top = 476
Width = 752
Height = 41
Align = alBottom
TabOrder = 0
object Button_show_current_APA: TButton
Left = 8
Top = 8
Width = 155
Height = 25
Caption = 'Show current APA'
ModalResult = 3
TabOrder = 0
OnClick = Button_show_current_APAClick
end
object Button_delete_all: TButton
Left = 330
Top = 8
Width = 155
Height = 25
Caption = 'Delete all req. blocks && cubes'
TabOrder = 1
OnClick = Button_delete_allClick
end
object Button_add_to_selection: TButton
Left = 169
Top = 8
Width = 155
Height = 25
Caption = 'Add to selection'
Enabled = False
ModalResult = 4
TabOrder = 2
OnClick = Button_add_to_selectionClick
end
object Button_Main_Menu: TButton
Left = 490
Top = 8
Width = 155
Height = 25
Caption = 'Back to Main Menu'
TabOrder = 3
OnClick = Button_Main_MenuClick
- 440 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end
end
object GroupBox1: TGroupBox
Left = 0
Top = 0
Width = 752
Height = 145
Align = alTop
Caption = 'Selection'
TabOrder = 1
object Label1: TLabel
Left = 120
Top = 20
Width = 52
Height = 13
Caption = 'Dimension:'
end
object Label2: TLabel
Left = 124
Top = 44
Width = 48
Height = 13
Caption = 'Hierarchy:'
end
object Label3: TLabel
Left = 133
Top = 68
Width = 39
Height = 13
Caption = 'Method:'
end
object Label4: TLabel
Left = 100
Top = 92
Width = 72
Height = 13
Caption = 'End of method:'
end
object Dimensionbox: TComboBox
Left = 184
Top = 16
Width = 421
Height = 21
Style = csDropDownList
ItemHeight = 13
ItemIndex = 0
TabOrder = 0
Text = 'NONE'
OnChange = DimensionboxChange
Items.Strings = (
'NONE')
end
object Hierarchybox: TComboBox
Left = 184
Top = 40
Width = 421
Height = 21
Style = csDropDownList
ItemHeight = 13
ItemIndex = 0
TabOrder = 2
Text = 'NONE'
OnChange = HierarchyboxChange
Items.Strings = (
'NONE')
end
object Methodbox: TComboBox
Left = 184
Top = 64
Width = 421
Height = 21
Style = csDropDownList
ItemHeight = 13
ItemIndex = 0
- 441 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
TabOrder = 4
Text = 'NONE'
OnChange = HierarchyboxChange
Items.Strings = (
'NONE'
'DRILL DOWN'
'ROLL UP')
end
object End_of_methodbox: TComboBox
Left = 184
Top = 88
Width = 421
Height = 21
Style = csDropDownList
ItemHeight = 13
ItemIndex = 0
TabOrder = 6
Text = 'NONE'
Items.Strings = (
'NONE')
end
object Button_insert: TButton
Left = 186
Top = 111
Width = 77
Height = 25
Caption = 'Insert'
TabOrder = 8
OnClick = Button_insertClick
end
object Button_delete: TButton
Left = 265
Top = 111
Width = 77
Height = 25
Caption = 'Delete'
Enabled = False
TabOrder = 1
OnClick = Button_deleteClick
end
object Button_Edit: TButton
Left = 345
Top = 111
Width = 77
Height = 25
Caption = 'Edit'
Enabled = False
TabOrder = 3
OnClick = Button_EditClick
end
object Button_Accept: TButton
Left = 424
Top = 111
Width = 75
Height = 25
Caption = 'Accept'
TabOrder = 5
OnClick = Button_AcceptClick
end
object Button_Cancel: TButton
Left = 504
Top = 111
Width = 75
Height = 25
Caption = 'Cancel'
TabOrder = 7
OnClick = Button_CancelClick
end
end
object Listeint: TListBox
Left = 602
Top = 145
Width = 150
Height = 331
- 442 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Align = alRight
ItemHeight = 13
TabOrder = 2
Visible = False
end
object Panel1: TPanel
Left = 0
Top = 145
Width = 193
Height = 331
Align = alLeft
TabOrder = 3
object Panel3: TPanel
Left = 1
Top = 1
Width = 191
Height = 238
Align = alTop
TabOrder = 0
object Button_new_requirement_block: TButton
Left = 8
Top = 8
Width = 169
Height = 25
Caption = 'New req. block'
TabOrder = 0
OnClick = Button_new_requirement_blockClick
end
object Button_del_req_block: TButton
Left = 8
Top = 61
Width = 169
Height = 25
Caption = 'Delete req. block'
Enabled = False
TabOrder = 1
OnClick = Button_del_req_blockClick
end
object Button_select: TButton
Left = 8
Top = 88
Width = 169
Height = 25
Caption = 'Select'
Enabled = False
TabOrder = 2
OnClick = Button_selectClick
end
object Button_Deselect: TButton
Left = 8
Top = 115
Width = 169
Height = 25
Caption = 'Deselect'
Enabled = False
TabOrder = 3
OnClick = Button_DeselectClick
end
object Button_Select_all: TButton
Left = 8
Top = 142
Width = 169
Height = 25
Caption = 'Select all'
TabOrder = 4
OnClick = Button_Select_allClick
end
object Button_Deselect_all: TButton
Left = 8
Top = 169
Width = 169
Height = 25
Caption = 'Deselect all'
TabOrder = 5
- 443 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
OnClick = Button_Deselect_allClick
end
object Button_Edit_Requirement_block: TButton
Left = 7
Top = 34
Width = 169
Height = 25
Caption = 'Edit req. block'
Enabled = False
TabOrder = 6
OnClick = Button_Edit_Requirement_blockClick
end
end
end
object Req: TTreeView
Left = 193
Top = 145
Width = 409
Height = 331
Align = alClient
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -13
Font.Name = 'MS Sans Serif'
Font.Style = []
Images = ImageList2
Indent = 19
ParentFont = False
ReadOnly = True
TabOrder = 4
OnClick = ReqClick
OnDblClick = ReqDblClick
end
object ImageList2: TImageList
Left = 448
Top = 288
Bitmap = {
494C010103000400040010001000FFFFFFFFFF10FFFFFFFFFFFFFFFF424D3600
0000000000003600000028000000400000001000000001002000000000000010
000000000000000000000000000000000000344E4A006BB09B006BB09B006BB0
. . .
. . .
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
000000000000}
end
end
12.1.31 UNIT APA_SELECTIONUNIT.PAS
unit APA_Selectionunit;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, ImgList, ComCtrls, StdCtrls, ExtCtrls;
type
TAPA_Selection_Screen = class(TForm)
Panel2: TPanel;
Button_show_current_APA: TButton;
Button_delete_all: TButton;
Button_add_to_selection: TButton;
Button_Main_Menu: TButton;
GroupBox1: TGroupBox;
Label1: TLabel;
Label2: TLabel;
Label3: TLabel;
Label4: TLabel;
Dimensionbox: TComboBox;
- 444 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Hierarchybox: TComboBox;
Methodbox: TComboBox;
End_of_methodbox: TComboBox;
Button_insert: TButton;
Button_delete: TButton;
Button_Edit: TButton;
Button_Accept: TButton;
Button_Cancel: TButton;
Listeint: TListBox;
Panel1: TPanel;
Panel3: TPanel;
Button_new_requirement_block: TButton;
Button_del_req_block: TButton;
Button_select: TButton;
Button_Deselect: TButton;
Button_Select_all: TButton;
Button_Deselect_all: TButton;
Button_Edit_Requirement_block: TButton;
Req: TTreeView;
ImageList2: TImageList;
procedure DimensionboxChange(Sender: TObject);
procedure HierarchyboxChange(Sender: TObject);
procedure Button_new_requirement_blockClick(Sender: TObject);
procedure Button_Edit_Requirement_blockClick(Sender: TObject);
procedure Button_selectClick(Sender: TObject);
procedure Button_DeselectClick(Sender: TObject);
procedure Button_del_req_blockClick(Sender: TObject);
procedure Button_insertClick(Sender: TObject);
procedure ReqClick(Sender: TObject);
procedure Button_Select_allClick(Sender: TObject);
procedure Button_Deselect_allClick(Sender: TObject);
procedure Button_deleteClick(Sender: TObject);
procedure Button_EditClick(Sender: TObject);
procedure Button_AcceptClick(Sender: TObject);
procedure Button_CancelClick(Sender: TObject);
procedure ReqDblClick(Sender: TObject);
procedure Button_show_current_APAClick(Sender: TObject);
procedure Button_add_to_selectionClick(Sender: TObject);
procedure Button_delete_allClick(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure Button_Main_MenuClick(Sender: TObject);
private
{ Private-Deklarationen }
public
{ Public-Deklarationen }
end;
var
APA_Selection_Screen: TAPA_Selection_Screen;
gotoAPA:boolean=false;
implementation
uses APA_Input_Reqblockunit, APA_Gridunit, APA_Parameterunit,
APA_Optionsunit, APA_Dialogunit, APA_Applicationunit;
{$R *.dfm}
var editmode:boolean =false;
editnode:TTreeNode;
anzblocksselected:longint =0;
function vergleichewuerfel(erster,zweiter:array of longint;Dimensionen:longint):longint;
var zahler:longint;
ergebnis0,ergebnisminus1:boolean;
begin
{Diese Funktion Vergleicht die beiden Würfel und gibt 1 zurück, wenn der Zweite kein
Derivate des ersten ist. 0 wenn gleich und sonst -1}
ergebnis0:=true;ergebnisminus1:=false;
For zahler:=0 to Dimensionen-1 do begin
if (erster[zahler]<zweiter[zahler]) then
ergebnisminus1:=true;
if (erster[zahler]<>zweiter[zahler]) then
ergebnis0:=false;
- 445 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end;
if ergebnisminus1=true then Result:=-1
else
if ergebnis0=false then Result:=1
else
Result:=0;
end;
function getbezeichnung():string;
var st2,st:string;
begin;
{Diese Funktion erzeugt die Bezeichnung für den Eintrag in der Anzeige}
with APA_Selection_Screen do begin
{Auflösen der Bezeichnung in der Spezialbox}
st2:=inttostr(dimensionbox.itemindex);while length(st2)<4 do st2:='0'+st2;
st:=st2;
st2:=inttostr(hierarchybox.itemindex);while length(st2)<4 do st2:='0'+st2;
st:=st+st2;
st2:=inttostr(Methodbox.itemindex);while length(st2)<4 do st2:='0'+st2;
st:=st+st2;
if Methodbox.ItemIndex<>2 then
st2:=inttostr(End_of_methodbox.itemindex) else
st2:=inttostr(End_of_methodbox.itemindex+1);
while length(st2)<4 do st2:='0'+st2;
st:=st+st2;
result:=st;
end;
end;
function kannzusetzen:boolean;
var
zahler:longint;
zusetzen,ende:boolean;
begin;
with APA_Selection_Screen do begin
zusetzen:=true;ende:=false;
zahler:=Req.Selected.AbsoluteIndex;
{Von der Position bis nach unten zum nächsten Req oder dem Ende}
repeat
if copy(Listeint.items[zahler],1,4)<>'Req:' then
if
(editmode=false)or((editmode=true)and(editnode.AbsoluteIndex<>zahler))
then begin
if
strtoint(copy(Listeint.Items[zahler],1,4))=Dimensionbox.ItemIndex then
zusetzen:=false;
end;
zahler:=zahler+1;if zahler>=Listeint.Items.Count-1 then begin;
ende:=true;zahler:=Listeint.items.count-1;
end;
until (copy(Listeint.Items[zahler],1,4)='Req:')or(ende=true);
{Von der Position bis nach oben zum nächsten Req oder zum Beginn}
ende:=false;
repeat;
if copy(Listeint.items[zahler],1,4)<>'Req:' then
if
(editmode=false)or((editmode=true)and(editnode.AbsoluteIndex<>zahler))
- 446 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
then begin
if
strtoint(copy(Listeint.Items[zahler],1,4))=Dimensionbox.ItemIndex then
zusetzen:=false;
end;
zahler:=zahler-1;if zahler<=0 then begin;ende:=true;zahler:=0;end;
if ende=false then begin
if
(copy(Listeint.items[zahler+1],1,4)='Req:')and(Listeint.Items.Count1=zahler+1) then
begin;
ende:=true;zahler:=zahler+1;
end;
end;
until (copy(Listeint.Items[zahler],1,4)='Req:')or(ende=true);
result:=zusetzen;
end;
end;
procedure buttonreqchange;
var aktindex:longint;
aktiviert:boolean;
begin;
with APA_Selection_Screen do begin
if Req.Enabled=true then Req.SetFocus;
{Suche den Status der Hierarchie}
if Req.Selected<>nil then aktindex:=Req.Selected.AbsoluteIndex
else aktindex:=0;
aktiviert:=false;
if Listeint.items.count>0 then begin
while(copy(Listeint.Items[aktindex],1,4)<>'Req:')and(aktindex>0) do begin
aktindex:=aktindex-1;
end;
if Req.Items[aktindex].ImageIndex<>2 then aktiviert:=true;
end;
if Editmode=true then begin
{Links alles deaktivieren}
Button_Edit_Requirement_Block.Enabled:=false;
Button_new_requirement_block.Enabled:=false;
Button_del_req_block.Enabled:=false;
Button_select.Enabled:=false;
Button_Deselect.Enabled:=false;
Button_Select_all.Enabled:=false;
Button_Deselect_all.Enabled:=false;
{Unten alles deaktivieren}
Button_show_current_APA.Enabled:=false;
Button_add_to_selection.Enabled:=false;
Button_delete_all.Enabled:=false;
{Oben nur Accept und Cancel aktivieren}
Button_Insert.Enabled:=false;
Button_Edit.Enabled:=false;
Button_Delete.Enabled:=false;
Button_Accept.Enabled:=true;
Button_Cancel.Enabled:=true;
Req.Enabled:=false;
end
else
begin;
{Unten alles aktivieren}
{anzblocksselected gibt die Anzahl der Selektieren Blocks wieder}
if anzblocksselected<>0 then begin;
- 447 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Button_show_current_APA.Enabled:=false;
Button_add_to_selection.Enabled:=true;
end else begin
Button_show_current_APA.Enabled:=true;
Button_add_to_selection.Enabled:=false;
end;
Button_delete_all.Enabled:=true;
if req.selected<>nil then begin
if aktiviert=true then begin
Button_Edit_Requirement_Block.Enabled:=true;
Button_new_requirement_block.Enabled:=true;
Button_del_req_block.Enabled:=true;
end else begin
Button_Edit_Requirement_Block.Enabled:=false;
Button_new_requirement_block.Enabled:=true;
Button_del_req_block.Enabled:=false;
end;
Button_Select_all.Enabled:=true;
Button_Deselect_all.Enabled:=true;
if req.Selected.Level=0 then begin
if req.Selected.ImageIndex=0 then begin
Button_select.Enabled:=true;
Button_Deselect.Enabled:=false;
end
else
begin
if req.Selected.ImageIndex=1 then begin
Button_select.Enabled:=false;
Button_Deselect.Enabled:=true;
end else begin
//Bereits zugesetzt
Button_select.Enabled:=false;
Button_Deselect.Enabled:=false;
end;
end;
{Ist eine Hierarchie ausgewählt dann alle deaktiveren außer insert}
if aktiviert=true then
Button_Insert.Enabled:=true
else
Button_Insert.Enabled:=false;
Button_Edit.Enabled:=false;
Button_Delete.Enabled:=false;
Button_Accept.Enabled:=false;
Button_Cancel.Enabled:=false;
Req.Enabled:=true;
end {of level 0}
else begin
{begin von level 1}
Button_Edit_Requirement_Block.Enabled:=false;
if aktiviert=true then
Button_new_requirement_block.Enabled:=true
else
Button_new_requirement_block.Enabled:=true;
Button_del_req_block.Enabled:=false;
Button_select.Enabled:=false;
Button_Deselect.Enabled:=false;
if aktiviert=true then begin
Button_Insert.Enabled:=true;
Button_Edit.Enabled:=true;
Button_Delete.Enabled:=true;
end
else
begin
Button_Insert.Enabled:=false;
Button_Edit.Enabled:=false;
Button_Delete.Enabled:=false;
- 448 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Req.Enabled:=false;
end;
Button_Accept.Enabled:=false;
Button_Cancel.Enabled:=false;
Req.Enabled:=true;
end;
end else begin
{Wenn nichts ausgewählt}
{Buttons links}
Button_Edit_Requirement_Block.Enabled:=false;
Button_new_requirement_block.Enabled:=true;
Button_del_req_block.Enabled:=false;
{Buttons oben}
if aktiviert=true then
Button_Insert.Enabled:=true
else
Button_Insert.Enabled:=false;
Button_Edit.Enabled:=false;
Button_Delete.Enabled:=false;
Button_Accept.Enabled:=false;
Button_Cancel.Enabled:=false;
Req.Enabled:=true;
end;
end;{of editmode}
end;
end;
procedure TAPA_Selection_Screen.DimensionboxChange(Sender: TObject);
var zahler:longint;
begin
if Dimensionbox.Text<>'NONE' then begin
hierarchybox.Items.Clear;
{Hole die Hierarchiestufen}
for zahler:=0 to anzh[Dimensionbox.itemindex]-1 do begin
Hierarchybox.Items.Add(dl[Dimensionbox.itemindex][zahler])
end;
Hierarchybox.ItemIndex:=0;
Methodbox.ItemIndex:=0;
end;
end;
procedure TAPA_Selection_Screen.HierarchyboxChange(Sender: TObject);
var zahler:longint;
begin
if Methodbox.itemindex<>0 then begin
End_of_methodbox.Enabled:=true;
if Methodbox.ItemIndex=2 then begin
{Bei einem Roll up}
End_of_Methodbox.Items.Clear;
{Hole die Hierarchiestufen}
for zahler:=hierarchybox.itemindex+1 to anzh[Dimensionbox.itemindex]-1 do begin
End_of_Methodbox.Items.Add(dl[Dimensionbox.itemindex][zahler])
end;
end else
begin
{Bei einem DRILL DOWN}
End_of_Methodbox.Items.Clear;
{Hole die Hierarchiestufen}
for zahler:=0 to hierarchybox.itemindex-1 do begin
End_of_Methodbox.Items.Add(dl[Dimensionbox.itemindex][zahler])
end;
- 449 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end;
end else begin;
End_of_methodbox.Enabled:=false;
End_of_methodbox.Items.Add('NONE');
end;
if End_of_Methodbox.Items.Count=0 then begin;
Methodbox.ItemIndex:=0;
End_of_methodbox.Enabled:=false;
End_of_methodbox.Items.Add('NONE');
end;
End_of_methodbox.ItemIndex:=0;
end;
procedure TAPA_Selection_Screen.Button_new_requirement_blockClick(
Sender: TObject);
var g:longint;
importancestring:string;
merkindex:longint;
ok:boolean;
begin
mustsave:=true;
{Ein Req}
APA_Insert_Reqblock.Reqname.Text:='';
APA_Insert_Reqblock.OKBtn.Enabled:=false;
APA_insert_Reqblock.Add_max_hier.Visible:=APA_Options.APA_Add_max_hier.checked;
APA_Insert_Reqblock.Add_max_hier.Enabled:=true;
repeat;
ok:=true;
if APA_Insert_Reqblock.showmodal=mrok then begin
for merkindex:=0 to Req.Items.Count-1 do begin
if copy(Listeint.Items[merkindex],1,3)='Req' then begin
if (copy(Req.items[merkindex].text,1,pos('//',Req.items[merkindex].Text)-1)=
APA_Insert_reqblock.reqname.Text) then begin
ok:=false;
showmessage('The name '+APA_Insert_reqblock.reqname.Text+' is already used. Please
change the name!');
end;
end;
end;
if ok=true then begin
if Req.TopItem<>nil then Req.Selected:=Req.TopItem;
importancestring:=APA_Parameter.APA_Degrees.Items[APA_Insert_Reqblock.Importance_o
f_requirement.Itemindex];
merkindex:=Req.Items.Add(req.Selected,APA_Insert_reqblock.reqname.Text+'//'+import
ancestring).AbsoluteIndex;
Req.Items[merkindex].ImageIndex:=0;
Req.Items[merkindex].SelectedIndex:=0;
Req.Selected:=Req.Items[Req.Items.count-1];
Listeint.Items.Add('Req:'+inttostr(APA_Insert_Reqblock.Importance_of_requirement.I
temindex));
if APA_insert_Reqblock.Add_max_hier.Checked=true then begin
{Zusetzen aller Dimensionen mit max. Hierarchielevels}
for g:=0 to Dimensionbox.Items.Count-1 do begin;
{Dimension einstellen}
Dimensionbox.ItemIndex:=g;DimensionboxChange(self);
{max Hierarchie einstellen}
- 450 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Hierarchybox.ItemIndex:=Hierarchybox.items.count-1;
{Methode ist Keine}
Methodbox.ItemIndex:=0;
{End of Methode ist auch keine}
End_of_Methodbox.ItemIndex:=0;
Button_insertClick(self);
end;
end;
end;//von ok
end else ok:=true;
until ok=true;
{Ein Req ENDE}
buttonreqchange;
Req.SetFocus;
end;
procedure TAPA_Selection_Screen.Button_Edit_Requirement_blockClick(
Sender: TObject);
var importancestring:string;
var ok:boolean;
var merkindex:longint;
begin
if Req.Selected<>nil then begin
try
{Ein Req}
APA_Insert_Reqblock.Reqname.Text:=copy(Req.Selected.text,1,pos('//',Req.Selected.T
ext)-1);
APA_Insert_Reqblock.OKBtn.Enabled:=false;
APA_insert_Reqblock.Add_max_hier.Visible:=false;
APA_Insert_Reqblock.Importance_of_requirement.ItemIndex:=
strtoint(copy(Listeint.Items[Req.Selected.Absoluteindex],5,255));
repeat;
ok:=true;
if APA_Insert_Reqblock.showmodal=mrok then begin
for merkindex:=0 to Req.Items.Count-1 do begin
if copy(Listeint.Items[merkindex],1,3)='Req' then begin
if (copy(Req.items[merkindex].text,1,pos('//',Req.items[merkindex].Text)-1)=
APA_Insert_reqblock.reqname.Text)and(Req.Selected<>Req.Items[merkindex]) then
begin
ok:=false;
showmessage('The name '+APA_Insert_reqblock.reqname.Text+' is already used. Please
change the name!');
end;
end;
end;
if ok=true then begin
importancestring:=APA_Parameter.APA_Degrees.Items[APA_Insert_Reqblock.Importance_o
f_requirement.Itemindex];
Req.Selected.Text:=APA_Insert_Reqblock.reqname.Text+'//'+importancestring;
Listeint.Items[Req.Selected.Absoluteindex]:='Req:'+inttostr(APA_Insert_Reqblock.Im
portance_of_requirement.Itemindex);
mustsave:=true;
end;//of ok
- 451 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end else ok:=true;
until ok=true;
{Ein Req ENDE}
buttonreqchange;
except
showmessage('Fehler beim Auflösen der Daten');
buttonreqchange;
exit;
end;
Req.SetFocus;
end;
end;
procedure TAPA_Selection_Screen.Button_selectClick(Sender: TObject);
begin
Req.Selected.ImageIndex:=1;
Req.Selected.SelectedIndex:=1;
anzblocksselected:=anzblocksselected+1;
buttonreqchange;
end;
procedure TAPA_Selection_Screen.Button_DeselectClick(Sender: TObject);
begin
if Req.Selected.ImageIndex=1 then begin
Req.Selected.ImageIndex:=0;
Req.Selected.SelectedIndex:=0;
anzblocksselected:=anzblocksselected-1;
buttonreqchange;
end;
end;
procedure TAPA_Selection_Screen.Button_del_req_blockClick(Sender: TObject);
var loschebis,zahler:longint;
begin
{Löschen der Einträge in Listeint}
{1. Lösch so lange bis das nächste Req kommt}
loschebis:=Req.Selected.AbsoluteIndex;
repeat;
loschebis:=loschebis+1;
until(copy(Listeint.items[loschebis+1],1,4)='Req:')
or(loschebis+1=Listeint.Items.Count-1);
if loschebis+1=Listeint.Items.Count-1 then loschebis:=loschebis+1;
for zahler:=0 to (loschebis-Req.Selected.AbsoluteIndex)
do Listeint.Items.Delete(Req.Selected.AbsoluteIndex);
Req.Selected.Delete;
buttonreqchange;
mustsave:=true;
end;
procedure TAPA_Selection_Screen.Button_insertClick(Sender: TObject);
var st,st2:string;
x:longint;
begin
if req.Selected=nil then begin;
APA_Insert_Reqblock.Add_max_hier.Enabled:=true;
APA_Insert_Reqblock.Add_max_hier.Checked:=false;
Button_new_requirement_block.Click;
Req.SetFocus;
end;
st2:=getbezeichnung(); {speichern der Spezialbezeichnung in st2}
if kannzusetzen()=true then begin{Zusetzen der Bezeichnung}
{Zusetzen der Anzeigebezeichnung in die Liste}
st:='Choose from '+Dimensionbox.Text+' hierarchy '+hierarchybox.text;
- 452 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if Methodbox.ItemIndex<>0 then begin
st:=st+' and a '+Methodbox.Text+' to '+End_of_Methodbox.Text;
end;
if req.Selected.Level=0 then
{wenn Dimension markiert}
x:=Req.Items.AddChild(Req.Selected,
st).AbsoluteIndex
else
{wenn Hierarchy markiert}
x:=Req.Items.Add(Req.Selected,
st).AbsoluteIndex;
{Zusetzen der Spezialbezeichnung in die Liste}
Listeint.Items.insert(x, st2);
Req.Items[x].ImageIndex:=6;
Req.Items[x].SelectedIndex:=6;
Req.selected.expand(true);
mustsave:=true;
end{End of Zusetzen}
else
showmessage('Diese Hierarchie wurde bereits zugesetzt');
buttonreqchange;
end;
procedure TAPA_Selection_Screen.ReqClick(Sender: TObject);
begin
buttonreqchange;
end;
procedure TAPA_Selection_Screen.Button_Select_allClick(Sender: TObject);
var zahler:longint;
begin
anzblocksselected:=0;
for zahler:=0 to Req.Items.Count-1 do begin
if (req.items[zahler].Level=0)and(req.Items[zahler].ImageIndex<>2) then begin
Req.items[zahler].ImageIndex:=1;
Req.items[zahler].SelectedIndex:=1;
anzblocksselected:=anzblocksselected+1;
end;
end;
Req.Repaint;
buttonreqchange;
end;
procedure TAPA_Selection_Screen.Button_Deselect_allClick(Sender: TObject);
var zahler:longint;
begin
for zahler:=0 to req.Items.Count-1 do begin
if (req.items[zahler].Level=0)and(Req.items[zahler].ImageIndex<>2) then begin
Req.items[zahler].ImageIndex:=0;
Req.items[zahler].SelectedIndex:=0;
end;
end;
Req.Repaint;
buttonreqchange;
anzblocksselected:=0;
buttonreqchange;
end;
procedure TAPA_Selection_Screen.Button_deleteClick(Sender: TObject);
begin
Listeint.Items.Delete(Req.Selected.AbsoluteIndex);
Req.Selected.Delete;
- 453 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
buttonreqchange;
mustsave:=true;
end;
procedure TAPA_Selection_Screen.Button_EditClick(Sender: TObject);
var st:string;
begin
if Req.Selected<>nil then begin
editnode:=Req.Selected;
editmode:=true;
{Daten laden}
st:=Listeint.Items[Req.Selected.Absoluteindex];
try
Dimensionbox.ItemIndex:=strtoint(copy(st,1,4));DimensionboxChange(self);
Hierarchybox.ItemIndex:=strtoint(copy(st,5,4));
Methodbox.ItemIndex:=strtoint(copy(st,9,4));
End_of_methodbox.ItemIndex:=strtoint(copy(st,13,4));
mustsave:=true;
except
showmessage('Fehler beim Auflösen der Daten');
editmode:=false;buttonreqchange;
exit;
end;
end;
buttonreqchange;
end;
procedure TAPA_Selection_Screen.Button_AcceptClick(Sender: TObject);
var st:string;
begin
editnode.Selected:=true;
if kannzusetzen()=true then begin{Zusetzen der Bezeichnung}
{Zusetzen der Anzeigebezeichnung in die Liste}
st:='Choose from '+Dimensionbox.Text+' hierarchy '+hierarchybox.text;
if Methodbox.ItemIndex<>0 then begin
st:=st+' and a '+Methodbox.Text+' to '+End_of_Methodbox.Text;
end;
Req.Selected.Text:=st;
{Zusetzen der Spezialbezeichnung in die Liste}
Listeint.Items[Req.Selected.AbsoluteIndex]:=getbezeichnung();
Req.selected.expand(true);
mustsave:=true;
end{End of Zusetzen}
else
showmessage('Diese Hierarchie wurde bereits zugesetzt');
editmode:=false;
buttonreqchange;
end;
procedure TAPA_Selection_Screen.Button_CancelClick(Sender: TObject);
begin
editmode:=false;
buttonreqchange;
end;
procedure TAPA_Selection_Screen.ReqDblClick(Sender: TObject);
begin
if copy(Listeint.items[Req.Selected.AbsoluteIndex],1,4)<>'Req:' then begin
if Button_Edit.Enabled=true then begin
Button_Edit.Click;
- 454 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end
else showmessage('Edit not allowed');
end;
end;
procedure TAPA_Selection_Screen.Button_show_current_APAClick(
Sender: TObject);
begin
gotoAPA:=true;
end;
procedure TAPA_Selection_Screen.Button_add_to_selectionClick(
Sender: TObject);
var akth:array of longint;
newbegin,newende,newakt:array of longint;
zahler,zahler2:longint;
spalte,zeile,aktdim:longint;
ende,endifredundant,endedieserzeile,enderollup:boolean;
copystring:string;
gewicht:longint;
begin
{Zusetzen der Selektierten Cubes zum APA}
mustsave:=true;
{1. Feststellen des Cubes, welcher zugesetzt wird}
for zahler:=0 to Listeint.Items.Count-1 do begin
if(copy(Listeint.Items[zahler],1,4)='Req:')and(Req.Items[zahler].ImageIndex=1) then
begin
Req.Items[Zahler].ImageIndex:=2;
Req.Items[Zahler].SelectedIndex:=2;
gewicht:=strtoint(copy(Listeint.Items[zahler],5,255));
newbegin:=nil;
setlength(newbegin,anzd);
newende:=nil;
setlength(newende,anzd);
{Alle Hierarchiestufen der Dimensionen auf max setzen}
for zahler2:=0 to anzd-1 do newbegin[zahler2]:=anzh[zahler2]-1;
for zahler2:=0 to anzd-1 do newende[zahler2]:=anzh[zahler2]-1;
zahler2:=zahler+1;copystring:=copy(Listeint.Items[zahler2],1,4);
while (copystring<>'Req:')and(zahler2<Listeint.Items.Count) do begin
{Auflösen des Eintrages in Listeint}
if (strtoint(copy(Listeint.Items[zahler2],9,4))=0) then begin;
{Wenn Method ist NONE also kein Dill Down oder Roll up}
newbegin[(strtoint(copy(Listeint.Items[zahler2],1,4)))]:=strtoint(copy(Listeint.It
ems[zahler2],5,4));
newende[(strtoint(copy(Listeint.Items[zahler2],1,4)))]:=strtoint(copy(Listeint.Ite
ms[zahler2],5,4));
end
else begin
{Wenn die Methode ein Drill Down oder Roll up}
if(strtoint(copy(Listeint.Items[zahler2],9,4))=1) then begin
{Drill Down}
newbegin[(strtoint(copy(Listeint.Items[zahler2],1,4)))]:=strtoint(copy(Listeint.It
ems[zahler2],13,4));
newende[(strtoint(copy(Listeint.Items[zahler2],1,4)))]:=strtoint(copy(Listeint.Ite
ms[zahler2],5,4));
end
else begin
{Roll up}
- 455 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
newbegin[(strtoint(copy(Listeint.Items[zahler2],1,4)))]:=strtoint(copy(Listeint.It
ems[zahler2],5,4));
newende[(strtoint(copy(Listeint.Items[zahler2],1,4)))]:=strtoint(copy(Listeint.Ite
ms[zahler2],13,4));
end;
end;//Ende von
Dill Down and Roll UP
zahler2:=zahler2+1;
if zahler2<Listeint.items.count
else copystring:='';
end;// Ende von while <> Req
then copystring:=copy(Listeint.Items[zahler2],1,4)
{2. Nach dem Feststellen, wie die Würfel aussehen sollen, welche zugesetzt werden
sollen,
werden wir das APA durchlaufen, um diesen zu suchen}
newakt:=nil;
setlength(newakt,anzd);
for zahler2:=0 to anzd-1 do newakt[zahler2]:=newbegin[zahler2];
enderollup:=true;
repeat;
//Hierarchie raufsetzen Beginn
aktdim:=0;
while (aktdim<anzd)and(enderollup=false) do begin;
{Hinaufsetzen einer Hierarchie}
if (newakt[aktdim]<newende[aktdim]) then begin;
newakt[aktdim]:=newakt[aktdim]+1;enderollup:=true;
end;
aktdim:=aktdim+1;
end;
//Hierarchie raufsetzen Ende
{Beginn der Überprüfung des Würfels}
zeile:=0;ende:=false;
while (zeile<anzzeilen)and(ende=false) do begin
//Erzeugen eines neuen Würfels
akth:=nil;
setlength(akth,anzd);
//Füllen des Würfels mit den untersten Hierarchiestufen
for zahler2:=0 to anzd-1 do akth[zahler2]:=0;
endifredundant:=false;endedieserzeile:=false;spalte:=0;
while(spalte<anzspalten)and(ende=false)and(endedieserzeile=false) do begin;
if (endifredundant=false)and(APA[spalte,zeile].farbe=clYellow) then
endifredundant:=true;
if (endifredundant=true)and(APA[spalte,zeile].farbe<>clYellow) then
endedieserzeile:=true;
akth[APA[spalte,zeile].countdimension]:=APA[spalte,zeile].counthier;
{3.Vergleiche die Würfel}
//Ist der Würfel redundanzfrei dann vergleiche
if (APA[spalte,zeile].farbe=clYellow) then begin
{a) Wenn eine der Hierarchiestufen einer Dimension größer ist, als jene
des gesuchten Würfel gehe in die nächste Zeile}
if vergleichewuerfel(newakt,akth,anzd)=-1 then endedieserzeile:=true;
{b) Wenn der gesuchte Würfel gefunden wurde dann starte als interessant
markieren bis der Endwürfel gefunden wurde oder Fall a) auftritt}
if endedieserzeile=false then begin;
- 456 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
if vergleichewuerfel(newakt,akth,anzd)=0 then begin;
APA[spalte,zeile].interessant:=true;
APA[spalte,zeile].gewicht:=strtoint(APA_Parameter.APA_Degreecounts.Items[gewicht])
;;
APA[spalte,zeile].gewichtlevel:=gewicht;
end;
end;//of Endedieserzeile
end;//Ende von clYellow Redundanzfrei
spalte:=spalte+1;
end;//Ende von Spalten und Ende=false
zeile:=zeile+1;
end;//Ende von Zeilen und Ende=false
enderollup:=false;
until (vergleichewuerfel(newakt,newende,anzd)=0);
end;//Ende von es ist ein Reqirement
end;//Ende von zahler
anzblocksselected:=0;
gotoAPA:=true;
buttonreqchange;
end;
procedure TAPA_Selection_Screen.Button_delete_allClick(Sender: TObject);
begin
APA_Dialog.APA_Text.Caption:='Are you sure to erase all cubes in the APA Selection
Screen and in the APA itself?';
if APA_Dialog.showmodal=mryes then begin
zellezeile:=0;
while (zellezeile<anzzeilen)do begin
zellespalte:=0;
while (zellespalte<anzspalten) do begin
APA[zellespalte,zellezeile].interessant:=false;
APA[zellespalte,zellezeile].materalisieren:=false;
APA[zellespalte,zellezeile].derivative:=false;
zellespalte:=zellespalte+1;
end;
zellezeile:=zellezeile+1;
end;
Req.Items.Clear;
Listeint.Items.Clear;
showmessage('Erasing complete !');
mustsave:=true;
end;
end;
procedure TAPA_Selection_Screen.FormShow(Sender: TObject);
begin
gotoAPA:=false;
Req.SetFocus;
buttonreqchange;
end;
procedure TAPA_Selection_Screen.Button_Main_MenuClick(Sender: TObject);
begin
Close;
end;
- 457 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
end.
12.1.32 UNIT APA_SHOW_COSTSUNIT.DFM
object APA_Showcosts: TAPA_Showcosts
Left = 220
Top = 114
Width = 696
Height = 480
Caption = 'Show Costs'
Color = clBtnFace
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -11
Font.Name = 'MS Sans Serif'
Font.Style = []
OldCreateOrder = False
Position = poScreenCenter
OnClose = FormClose
OnShow = FormShow
PixelsPerInch = 96
TextHeight = 13
object Panel1: TPanel
Left = 0
Top = 0
Width = 688
Height = 41
Align = alTop
TabOrder = 0
object Button2: TButton
Left = 16
Top = 8
Width = 89
Height = 25
Caption = 'Export to Excel'
TabOrder = 0
OnClick = Button2Click
end
end
object Panel2: TPanel
Left = 0
Top = 405
Width = 688
Height = 41
Align = alBottom
TabOrder = 1
object Button1: TButton
Left = 16
Top = 8
Width = 75
Height = 25
Cancel = True
Caption = 'Close && Save'
TabOrder = 0
OnClick = Button1Click
end
object Button3: TButton
Left = 104
Top = 8
Width = 75
Height = 25
Caption = 'Abort'
TabOrder = 1
OnClick = Button3Click
end
end
object Kostengriddat: TStringGrid
Left = 0
Top = 41
Width = 688
Height = 364
Align = alClient
- 458 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
ColCount = 7
DefaultColWidth = 60
DefaultRowHeight = 20
Options = [goFixedVertLine, goFixedHorzLine, goVertLine, goHorzLine, goRangeSelect,
goColSizing, goEditing]
TabOrder = 2
OnGetEditMask = KostengriddatGetEditMask
OnSetEditText = KostengriddatSetEditText
end
object OpenDialogcosts: TOpenDialog
DefaultExt = 'xls'
Filter = 'Excel Files|*.xls'
Left = 376
Top = 224
end
end
12.1.33 UNIT APA_SHOW_COSTSUNIT.PAS
unit APA_Show_costsunit;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, Grids, ExtCtrls, ComObj;
type
TAPA_Showcosts = class(TForm)
Panel1: TPanel;
Panel2: TPanel;
Button2: TButton;
OpenDialogcosts: TOpenDialog;
Kostengriddat: TStringGrid;
Button1: TButton;
Button3: TButton;
procedure Button1Click(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
procedure Button2Click(Sender: TObject);
procedure KostengriddatSetEditText(Sender: TObject; ACol,
ARow: Integer; const Value: String);
procedure KostengriddatGetEditMask(Sender: TObject; ACol,
ARow: Integer; var Value: String);
procedure Button3Click(Sender: TObject);
private
{ Private-Deklarationen }
public
{ Public-Deklarationen }
end;
var
APA_Showcosts: TAPA_Showcosts;
implementation
uses APA_Applicationunit;
{$R *.dfm}
var wurdebearbeitet:boolean;
procedure TAPA_Showcosts.Button1Click(Sender: TObject);
begin
Close;
end;
procedure TAPA_Showcosts.FormShow(Sender: TObject);
var counter:longint;
var zeile:longint;
begin
wurdebearbeitet:=false;
- 459 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');
reset(fKosten);
try
Kostengriddat.Cells[1,0]:='FromColumn';
Kostengriddat.Cells[2,0]:='FromRow';
Kostengriddat.Cells[3,0]:='ToColumn';
Kostengriddat.Cells[4,0]:='ToRow';
Kostengriddat.Cells[5,0]:='Query';
Kostengriddat.Cells[6,0]:='Build';
counter:=filesize(fKosten);
Kostengriddat.RowCount:=counter-1;
Kostengriddat.ColWidths[0]:=25;
zeile:=0;
while zeile<counter do begin
zeile:=zeile+1;
if zeile<counter-1 then begin
seek(fKosten,zeile-1);
read(fKosten,vKosten);
Kostengriddat.Cells[0,zeile]:=inttostr(zeile);
Kostengriddat.Cells[1,zeile]:=inttostr(vKosten.VonSpalte);
Kostengriddat.Cells[2,zeile]:=inttostr(vKosten.VonZeile);
Kostengriddat.Cells[3,zeile]:=inttostr(vKosten.ZuSpalte);
Kostengriddat.Cells[4,zeile]:=inttostr(vKosten.ZuZeile);
Kostengriddat.Cells[5,zeile]:=Floattostrf(vKosten.Query,fffixed,9,0);
Kostengriddat.Cells[6,zeile]:=Floattostrf(vKosten.Build,fffixed,9,0);
end;
end;
finally
CloseFile(fKosten);
end;
end;
procedure TAPA_Showcosts.FormClose(Sender: TObject;
var Action: TCloseAction);
var counter:longint;
var zeile:longint;
begin
if wurdebearbeitet=true then begin
assignfile(fKosten,'C:\APADIR\DATA\Kosten.dat');
mustsave:=true;
rewrite(fKosten);
try
counter:=Kostengriddat.RowCount;
//Testlauf, ob alle Eingaben OK
zeile:=0;
while zeile<counter do begin
zeile:=zeile+1;
if zeile<counter-1 then begin
vKosten.VonSpalte:=strtoint(trim(Kostengriddat.Cells[1,zeile]));
vKosten.VonZeile:=strtoint(trim(Kostengriddat.Cells[2,zeile]));
vKosten.ZuSpalte:=strtoint(trim(Kostengriddat.Cells[3,zeile]));
vKosten.ZuZeile:=strtoint(trim(Kostengriddat.Cells[4,zeile]));
vKosten.Query:=strtoint(trim(Kostengriddat.Cells[5,zeile]));
vKosten.Build:=strtoint(trim(Kostengriddat.Cells[6,zeile]));
end;
end;
zeile:=0;
while zeile<counter do begin
zeile:=zeile+1;
if zeile<counter-1 then begin
seek(fKosten,filesize(fKosten));
- 460 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
vKosten.VonSpalte:=strtoint(trim(Kostengriddat.Cells[1,zeile]));
vKosten.VonZeile:=strtoint(trim(Kostengriddat.Cells[2,zeile]));
vKosten.ZuSpalte:=strtoint(trim(Kostengriddat.Cells[3,zeile]));
vKosten.ZuZeile:=strtoint(trim(Kostengriddat.Cells[4,zeile]));
vKosten.Query:=strtoint(trim(Kostengriddat.Cells[5,zeile]));
vKosten.Build:=strtoint(trim(Kostengriddat.Cells[6,zeile]));
write(fKosten,vKosten);
end;
end;
finally
CloseFile(fKosten);
end;
end;
end;
procedure TAPA_Showcosts.Button2Click(Sender: TObject);
var zeile : Integer;
var Excel : variant;
var counter:longint;
begin
try
assignfile(fKosten,'c:\APADIR\DATA\Kosten.dat');
reset(fKosten);
try
if opendialogcosts.Execute then begin
try
try
Excel := GetactiveOleObject('Excel.Application');
except
try
Excel := CreateOleObject('Excel.Application');
try
Excel.Workbooks.Open (Filename:=opendialogcosts.filename);
except
Excel.Workbooks.add;
Excel.ActiveWorkbook.SaveAs (Filename:=Opendialogcosts.filename);
end;
except
ShowMessage('Excel konnte nicht gestartet werden !');
Exit;
end;
end;
counter:=0;
Excel.Visible := false;
{ für die testphase sinnvoll }
Excel.sheets[1].select;
Excel.sheets.add;
Excel.sheets[1].Name := 'Export';
zeile:=1;
application.ProcessMessages;
{Überschriften}
Excel.Cells[zeile,
Excel.Cells[zeile,
Excel.Cells[zeile,
Excel.Cells[zeile,
Excel.Cells[zeile,
Excel.Cells[zeile,
1].Value
2].Value
3].Value
4].Value
5].Value
6].Value
:=
:=
:=
:=
:=
:=
'FromColumn';
'FromRow';
'ToColumn';
'ToRow';
'Query';
'Build';
application.ProcessMessages;
repeat;
zeile:=zeile+1;
counter:=counter+1;
if counter<filesize(fKosten) then begin
- 461 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
seek(fKosten,counter);
read(fKosten,vKosten);
application.ProcessMessages;
Excel.Cells[zeile,
Excel.Cells[zeile,
Excel.Cells[zeile,
Excel.Cells[zeile,
Excel.Cells[zeile,
Excel.Cells[zeile,
1].Value
2].Value
3].Value
4].Value
5].Value
6].Value
:=
:=
:=
:=
:=
:=
vKosten.VonSpalte;
vKosten.VonZeile;
vKosten.ZuSpalte;
vKosten.ZuZeile;
vKosten.Query;
vKosten.Build;
application.ProcessMessages;
end;
until (counter>=filesize(fKosten));
Application.BringToFront;
showmessage('Data saved');
finally
Excel.visible:=true;
Application.BringToFront;
Excel.Visible := false; Excel.visible:=true;
Excel.workbooks.Close;
end;
end;{opendialog1}
finally
end;
finally
CloseFile(fKosten);
end;
end;
procedure TAPA_Showcosts.KostengriddatSetEditText(Sender: TObject; ACol,
ARow: Integer; const Value: String);
begin
wurdebearbeitet:=true;
end;
procedure TAPA_Showcosts.KostengriddatGetEditMask(Sender: TObject; ACol,
ARow: Integer; var Value: String);
begin
Value := '!000000000;1';
end;
procedure TAPA_Showcosts.Button3Click(Sender: TObject);
begin
wurdebearbeitet:=false;
Close;
end;
end.
12.1.34 UNIT APA_SQLUNIT.DFM
object APA_Sql: TAPA_Sql
Left = 220
Top = 114
Width = 696
Height = 480
Caption = 'APA Sql Scripts'
Color = clBtnFace
Font.Charset = DEFAULT_CHARSET
- 462 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Font.Color = clWindowText
Font.Height = -11
Font.Name = 'MS Sans Serif'
Font.Style = []
OldCreateOrder = False
Position = poScreenCenter
PixelsPerInch = 96
TextHeight = 13
object Panel1: TPanel
Left = 0
Top = 400
Width = 688
Height = 46
Align = alBottom
TabOrder = 0
object Button1: TButton
Left = 306
Top = 10
Width = 75
Height = 25
Cancel = True
Caption = 'Close'
TabOrder = 0
OnClick = Button1Click
end
end
object SQLtext: TRichEdit
Left = 0
Top = 41
Width = 688
Height = 359
Align = alClient
ScrollBars = ssBoth
TabOrder = 1
end
object Panel2: TPanel
Left = 0
Top = 0
Width = 688
Height = 41
Align = alTop
TabOrder = 2
object Button2: TButton
Left = 16
Top = 8
Width = 121
Height = 25
Caption = 'Save SQL Script'
TabOrder = 0
OnClick = Button2Click
end
end
object SaveDialogsql: TSaveDialog
DefaultExt = 'SQL'
Filter = 'SQL Script|*.sql'
Left = 264
Top = 144
end
end
12.1.35 UNIT APA_SQLUNIT.PAS
unit APA_Sqlunit;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, ExtCtrls, ComCtrls;
type
TAPA_Sql = class(TForm)
- 463 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
Panel1: TPanel;
Button1: TButton;
SQLtext: TRichEdit;
Panel2: TPanel;
Button2: TButton;
SaveDialogsql: TSaveDialog;
procedure Button1Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
private
{ Private-Deklarationen }
public
{ Public-Deklarationen }
end;
var
APA_Sql: TAPA_Sql;
implementation
uses APA_Optionsunit;
{$R *.dfm}
procedure TAPA_Sql.Button1Click(Sender: TObject);
begin
Close;
end;
procedure TAPA_Sql.Button2Click(Sender: TObject);
var SaveFile:TextFile;
var zahler:longint;
begin
Savedialogsql.InitialDir:=APA_Options.APA_Save_Path.Directory;
if savedialogsql.Execute then begin
AssignFile(SaveFile,Savedialogsql.FileName);
{$I-}
Rewrite(SaveFile);
{$I+}
if IOResult = 0 then
begin
for zahler:=0 to Sqltext.lines.count-1 do begin
writeln(SaveFile,SQLtext.lines[zahler]);
end;
CloseFile(SaveFile);
end
else
MessageDlg('File access error', mtWarning, [mbOk], 0);
end;
end;
end.
12.2 QUELLCODES DER HILFEDATEIEN
12.2.1
INDEX.HTM
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
<meta http-equiv="Content-Language" content="de">
<title>Willkommen</title>
<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
<meta name="ProgId" content="FrontPage.Editor.Document">
- 464 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
<meta name="Microsoft Theme" content="blank 1111, default">
<meta name="Microsoft Border" content="tlb, default">
</head>
<body><p>Welcome to the APA Helpfile Website. This site should help you working with
the APA program developed by Thomas Achs 2004. Use the Links above to navigate
to special help topics.<p align="center"><img border="0" src="images/corel1.jpg"
width="233" height="182">
<p>The APA (Aggregation Path Array) is a semi-graphical data modelling method in a data
warehouse.<br>
This programm helps you to</p>
<ul>
<li>paint the APA </li>
<li> show the redundancy-free set </li>
<li> get the required cubes marked in the set </li>
<li> see the derivatives of one cube </li>
<li> see the sum of the derivatives of many cubes </li>
<li> compare the required cubes and the materialized cubes </li>
<li>calculate the materialized cubes with Thomas Achs heuristic</li>
</ul>
<p align="center"> 
<p> </body>
</html>
12.2.2
APA_GRID_SCREEN.HTM
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
<meta http-equiv="Content-Language" content="de">
<title>APA Help - APA Grid</title>
<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
<meta name="ProgId" content="FrontPage.Editor.Document">
<meta name="Microsoft Theme" content="blank 1111, default">
<meta name="Microsoft Border" content="tlb, default">
</head>
<body>
<p>The APA Grid Screen shows the APA. This screen offers a lot of functions and
useful operations.</p>
<p><img border="0" src="images/corel101.jpg" width="647" height="349"></p>
<h2><u>TOPICS</u></h2>
<h2><a name="Start">Show descriptions of cubes</a></h2>
<p><a href="#Show short description">Show short description</a><a href="#Show long
description"><br>
Show long description</a></p>
<h2>Required cubes</h2>
<p><a href="#Add required cubes">Add required cubes<br>
</a><a href="#Remove required cube">Remove required cube<br>
</a><a href="#Remove all required cubes">Remove all required cubes</a></p>
<h2>Materialized cubes</h2>
<p><a href="#Add materialized cube">Add materialized cube<br>
</a><a href="#Remove materialized cube">Remove materialized cube<br>
</a><a href="#Remove all materialized cubes">Remove all materialized cubes</a></p>
<h2>Derivates</h2>
<p><a href="#Show derivatives">Show derivates<br>
</a><a href="#Remove derivatives">Remove derivates</a></p>
<h2>Redundant cubes</h2>
<p><a href="#Show redundancy free cubes">Show redundancy free cubes</a></p>
<h2>Heuristik</h2>
<p><a href="#Generate materialized cubes">Generate materialized cubes</a></p>
<h2>Permutation</h2>
<p><a href="#Find deterministic solution by permutation">Find deterministic
solution by permutation</a></p>
<h2>Combination</h2>
<p><a href="#Find deterministic solution by combination">Find deterministic
solution by combination</a></p>
<h2>Deterministic solution</h2>
<p><a href="#Show deterministic solution">Show deterministic solution<br>
- 465 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
</a><a href="#Remove deterministic solution">Remove deterministic solution</a></p>
<h2>Possible cubes</h2>
<p><a href="#Show possible cubes">Show possible cubes<br>
</a><a href="#Remove possible cubes">Remove possible cubes</a></p>
<h2>Build SQL Statements</h2>
<p><a href="#Build SQL statements for star schema">Build SQL statements for star
schema<br>
</a><a href="#Build SQL statements for fact constellation schema">Build SQL
statements for fact constellation schema<br>
</a><a href="#Get Query of cube">Get Query of cube<br>
</a><a href="#Save SQL Script">Save SQL Script</a></p>
<h2>Use Random Costs</h2>
<p><a href="#Set use random costs">Set use random costs</a></p>
<hr>
<h2><a name="Show short description">Show short description</a></h2>
<p>In order to get the detailed description of a cube move the mouse over the
cell and see the short description in the status bar above.</p>
<p><img border="0" src="images/corel064.jpg" width="647" height="349"></p>
<h2><a name="Show long description">Show long description</a></h2>
<p>To get the right long description of a cube click the cell with the left
mouse button.</p>
<p><img border="0" src="images/corel102.jpg" width="647" height="349"></p>
<h2><a name="Add required cubes">Add required cubes</a></h2>
<p>In order to add a required cube move to the cell and press the right mouse
button. Choose required and the right importance.</p>
<p><img border="0" src="images/corel058.jpg" width="100%" height="100%"></p>
<p><img border="0" src="images/corel059.jpg" width="909" height="541"></p>
<h2><a name="Remove required cube">Remove required cube</a></h2>
<p>In order to remove a required cube select the cube an press the right mouse
button and select "Not required".</p>
<p><img border="0" src="images/corel103.jpg" width="647" height="349"></p>
<h2><a name="Remove all required cubes">Remove all required cubes</a></h2>
<p><img border="0" src="images/corel104.jpg" width="647" height="349"></p>
<h2><a name="Add materialized cube">Add materialized cube</a></h2>
<p><img border="0" src="images/corel066.jpg" width="647" height="349"></p>
<p><img border="0" src="images/corel067.jpg" width="647" height="349"></p>
<h2><a name="Remove materialized cube">Remove materialized cube</a></h2>
<p><img border="0" src="images/corel068.jpg" width="647" height="349"></p>
<h2><a name="Remove all materialized cubes">Remove all materialized cubes</a></h2>
<p>In order to remove all materialized cubes press the button "Remove
materialized cubes".</p>
<p><img border="0" src="images/corel072.jpg" width="647" height="349"></p>
<h2><a name="Show derivatives">Show derivatives</a></h2>
<p>In order to show a derivatives of a cube select the cube and press the right
mouse button and select "Show derivatives".</p>
<p><img border="0" src="images/corel069.jpg" width="647" height="349"></p>
<p><img border="0" src="images/corel070.jpg" width="647" height="349"></p>
<h2><a name="Remove derivatives">Remove derivatives</a></h2>
<p>In order to remove the derivatives press the button "Remove
derivatives".</p>
<p><img border="0" src="images/corel071.jpg" width="647" height="349"></p>
<h2><a name="Show redundancy free cubes">Show redundancy free cubes</a></h2>
<p>If you want to remove the redundant cubes of the APA tick "Remove
redundancy".</p>
<p><img border="0" src="images/corel074.jpg" width="647" height="349"></p>
<h2><a name="Generate materialized cubes">Generate materialized cubes</a></h2>
<p>After you have selected all your required cubes the Thomas ACHS heuristc,
will calculate the right cubes, which should be materialized.</p>
<p><img border="0" src="images/corel075.jpg" width="647" height="349"></p>
<p>Select "Search using Thomas Achs heuristic" in the menu and the
cubes will be selected.</p>
<p><img border="0" src="images/corel076.jpg" width="647" height="349"></p>
<p><img border="0" src="images/corel077.jpg" width="328" height="310"></p>
<p>The Screen below shows the calculated set of materialized cubes.</p>
<p><img border="0" src="images/corel078.jpg" width="647" height="349"></p>
<h2><a name="Find deterministic solution by permutation">Find deterministic
solution by permutation</a></h2>
<p>In oder to proof the heuristic the deterministic solution must be calculated.
If you want to do that by permutation select "Alogirthm permutation"
in the menu.</p>
<p><img border="0" src="images/corel079.jpg" width="647" height="349"></p>
<p><img border="0" src="images/corel080.jpg" width="302" height="150"></p>
<p><img border="0" src="images/corel081.jpg" width="328" height="310"></p>
<h2><a name="Find deterministic solution by combination">Find deterministic
- 466 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
solution by combination</a></h2>
<p>In oder to proof the heuristic the deterministic solution must be calculated.
If you want to do that by combination select "Alogirthm combitation"
in the menu.</p>
<p><img border="0" src="images/corel082.jpg" width="647" height="349"></p>
<p><img border="0" src="images/corel083.jpg" width="302" height="150"></p>
<p><img border="0" src="images/corel084.jpg" width="328" height="310"></p>
<h2><a name="Show deterministic solution">Show deterministic solution</a></h2>
<p>To have a look at the deterministic solution press "Show deterministic
solution".</p>
<p><img border="0" src="images/corel085.jpg" width="647" height="349"></p>
<p><img border="0" src="images/corel086.jpg" width="647" height="349"></p>
<h2><a name="Remove deterministic solution">Remove deterministic solution</a></h2>
<p>In order to remove the deterministic solution press "Remove
deterministic solution".</p>
<p><img border="0" src="images/corel087.jpg" width="647" height="349"></p>
<h2><a name="Show possible cubes">Show possible cubes</a></h2>
<p>If you want to see the set of possible cubes press "Show possible
cubes".</p>
<p><img border="0" src="images/corel088.jpg" width="647" height="349"></p>
<p><img border="0" src="images/corel089.jpg" width="161" height="110"></p>
<p><img border="0" src="images/corel090.jpg" width="647" height="349"></p>
<h2><a name="Remove possible cubes">Remove possible cubes</a></h2>
<p>If you want to remove the set of possible cubes press "Remove possible
cubes".</p>
<p><img border="0" src="images/corel091.jpg" width="647" height="349"></p>
<h2><a name="Build SQL statements for star schema">Build SQL statements for star
schema</a></h2>
<p>In order to create the SQL Statements for the star schema select "Generate
CREATE SQL-statements for star schema- Generate CREATE SQL-statements BFT and
dimension tables".</p>
<p><img border="0" src="images/corel093.jpg" width="946" height="349"></p>
<p><img border="0" src="images/corel094.jpg" width="696" height="480"></p>
<h2><a name="Build SQL statements for fact constellation schema">Build SQL
statements for fact constellation schema</a></h2>
<p>In order to create the SQL Statements for the star schema select "Generate
CREATE SQL-statements for fact constellation schema- Generate CREATE
SQL-statements BFT and dimension tables". If you want to create the
SQL-statements for the aggregated fact tables select  "Generate CREATE
SQL-statements for fact constellation schema- Generate CREATE SQL-statements for
materialized cubes".</p>
<p><img border="0" src="images/corel098.jpg" width="946" height="349"></p>
<p><img border="0" src="images/corel099.jpg" width="946" height="349"></p>
<h2><a name="Get Query of cube">Get Query of cube</a></h2>
<p>If you want to know the query of a cube select the cube, press right mouse
button and select "Get SQL statement to query this cube".</p>
<p><img border="0" src="images/corel105.jpg" width="647" height="466"></p>
<p><img border="0" src="images/corel106.jpg" width="696" height="480"></p>
<h2><a name="Save SQL Script">Save SQL Script</a></h2>
<p>If you want to save a SQL script press the button "Save SQL Script"
and choose the name.</p>
<p><img border="0" src="images/corel094.jpg" width="696" height="480"></p>
<p><img border="0" src="images/corel097.jpg" width="563" height="419"></p>
<h2><a name="Set use random costs">Set use random costs</a></h2>
<p>If you want to calculate with random costs or not chosse "Use random
costs" in Settings menu.</p>
<p><img border="0" src="images/corel100.jpg" width="946" height="349"></body>
</html>
12.2.3
APA_INPUT_SCREEN.HTM
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
<meta http-equiv="Content-Language" content="de">
<title>APA Help - APA Input Screen</title>
<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
<meta name="ProgId" content="FrontPage.Editor.Document">
<meta name="Microsoft Theme" content="blank 1111, default">
- 467 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
<meta name="Microsoft Border" content="tlb, default">
</head>
<body><p><a name="The APA">The APA</a> Input Screen helps you to insert all
the dimensions,
hierarchies and key figures.</p>
<p><a href="#Insert a dimension">Insert a dimension</a><a href="#Insert hierarchy"><br>
Insert a hierarchy level</a><a href="#Change dimension"><br>
Change a dimension</a><a href="#Change a hierarchy"><br>
Change a hierarchy level</a><a href="#Delete a dimension or hierarchy level"><br>
Delete a dimension or hierarchy level</a><a href="#Insert a key figure"><br>
Insert key figure</a><a href="#Edit a key figure"><br>
Edit key figure</a><a href="#Delete a key figure"><br>
Delete key figure</a></p>
<img border="0" src="images/corel002.jpg" width="604" height="568">
<p><a href="#The APA">Go to Top</a></p>
<hr>
<h1><a name="Insert a dimension">Insert a dimension</a></h1>
<p>To add a dimension press the button "Insert dimension" and the
Insert-dimension-screen will open.</p>
<p><img border="0" src="images/corel004.jpg" width="604" height="568"></p>
<p>Type the description of the new dimension in the "Dimension description"
textfield and press "OK".</p>
<p><img border="0" src="images/corel003.jpg" width="326" height="157"></p>
<p>The new dimension will be added to your "Input Screen".</p>
<p><img border="0" src="images/corel005.jpg" width="604" height="568"></p>
<p><a href="#The APA">Go to Top</a></p>
<h1><a name="Insert hierarchy">Insert hierarchy</a></h1>
<p>To add a new hierarchy select the dimension you want to add the new hierarchy
and press the Button "Insert hierarchy".</p>
<p><img border="0" src="images/corel006.jpg" width="604" height="568"></p>
<p>Type your data into the textfields and press "OK".</p>
<p><img border="0" src="images/corel007.jpg" width="331" height="241"></p>
<p>The hierarchy will be added to your dimension in the "Input
Screen". It´s possible to change the order of the hierarchies by using the
"Up" and "Down" buttons on the left.</p>
<p><img border="0" src="images/corel008.jpg" width="604" height="568"></p>
<p><a href="#The APA">Go to Top</a></p>
<h1><a name="Change dimension">Change a dimension</a></h1>
<p>To change a dimension select the dimension in the "Input Screen"
and press the button "Edit".</p>
<p><img border="0" src="images/corel009.jpg" width="604" height="568"></p>
<p>Change the description of the dimension and press "OK".</p>
<p><img border="0" src="images/corel010.jpg" width="326" height="157"></p>
<p>The new description of the dimension will be changed in the "Input
Screen".</p>
<p><img border="0" src="images/corel011.jpg" width="604" height="568"></p>
<p><a href="#The APA">Go to Top</a></p>
<h1><a name="Change a hierarchy">Change a hierarchy</a></h1>
<p>To change a hierarchy select the hierarchy in the "Input Screen"
and press the button "Edit".</p>
<p><img border="0" src="images/corel012.jpg" width="604" height="568"></p>
<p>Type in the changed data and press the button "OK".</p>
<p><img border="0" src="images/corel013.jpg" width="331" height="241"></p>
<p>The hierarchy will be changed in the "Input Screen".</p>
<p><img border="0" src="images/corel014.jpg" width="604" height="568"></p>
<p><a href="#The APA">Go to Top</a></p>
<h1><a name="Delete a dimension or hierarchy level">Delete a dimension or
hierarchy level</a></h1>
<p>Select the dimension or hierarchy level and press the button "Delete".</p>
<p><img border="0" src="images/corel021.jpg" width="604" height="568"></p>
<p>The dimension or hierarchy level will be erased from the "Input
Screen".</p>
<p><img border="0" src="images/corel022.jpg" width="604" height="568"></p>
<a href="#The APA">Go to Top</a>
<h1><a name="Insert a key figure">Insert a key figure</a></h1>
<p>In order to insert a key figure press the Button "Insert".</p>
<p><img border="0" src="images/corel028.jpg" width="327" height="237"></p>
<p>Enter data into the "APA Insert Key" form and press "OK".</p>
<p><img border="0" src="images/corel029.jpg" width="604" height="477"></p>
<p>
<a href="#The APA">Go to Top</a>
</p>
<h1><a name="Edit a key figure">Edit a key figure</a></h1>
- 468 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
<p>In order to edit a key figure select the figure and press the button
"Edit".</p>
<p><img border="0" src="images/corel028.jpg" width="327" height="237"></p>
<p>Change data in the "APA Insert Key" form and press "OK".</p>
<p><img border="0" src="images/corel029.jpg" width="604" height="477"></p>
<p>
<a href="#The APA">Go to Top</a>
</p>
<h1><a name="Delete a key figure">Delete a key figure</a></h1>
<p>In order to delete a key figure please select the figure and press the Button
"Delete".</p>
<p><img border="0" src="images/corel042.jpg" width="604" height="568"></p>
<p>
<a href="#The APA">Go to Top</a>
</p>
</body>
</html>
12.2.4
APA_INSTALL.HTM
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
<meta http-equiv="Content-Language" content="de">
<title>Installation</title>
<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
<meta name="ProgId" content="FrontPage.Editor.Document">
<meta name="Microsoft Theme" content="blank 1111, default">
<meta name="Microsoft Border" content="b">
</head>
<body><h5 align="center"><!--webbot bot="Navigation" s-type="banner" srendering="graphics"
s-orientation b-include-home b-include-up U-Page S-Target --></h5>
<p align="center"><!--webbot bot="Navigation" S-Type="siblings" SOrientation="horizontal"
S-Rendering="graphics" B-Include-Home="TRUE" B-Include-Up="FALSE" U-Page
S-Target -->
</p>
<h2><span style="text-transform: uppercase">How to install the APAWin
program</span></h2>
<hr>
<p><strong>Valid for:</strong> APAWin Version 1<br>
<strong>Date:</strong><!--WEBBOT
bot=TimeStamp
S-Type="EDITED"
S-Format="%d. %b %y"
--> </p>
<hr>
<h3>OVERWIEW</h3>
<p>This guide helps you install the APA program. There are two setup procedures
nessesary to install the APA programm. First the database driver must be
installed. You need administrator rights on your computer to run the setup.
Second the APA program need to be installed. The setup programm installs all
files required in the folder 'C:\APADIR'. Do not changed the name of the folder.
This chause problems in running the software.</p>
<hr>
<h3>HOW TO GO</h3>
<ol>
<li>Download the SETUP.exe file to your computer and start the setup.<br>
<img border="0" src="images/corel136.jpg" width="719" height="542">
</li>
<li>The Setup program will start. The press "Weiter".<br>
<img border="0" src="images/corel138.jpg" width="504" height="386">
</li>
<li>Please wait a few seconds...<br>
</li>
<li><img border="0" src="images/corel139.jpg" width="504" height="386">
- 469 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
</li>
<li>The installation finished.<br>
<br>
<img border="0" src="images/corel140.jpg" width="504" height="386">
</li>
</ol>
 </body>
</html>
12.2.5
APA_MAINMENU.HTM
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
<meta http-equiv="Content-Language" content="de">
<title>APA Help - APA Mainmenu</title>
<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
<meta name="ProgId" content="FrontPage.Editor.Document">
<meta name="Microsoft Theme" content="blank 1111, default">
<meta name="Microsoft Border" content="tlb, default">
</head>
<body>
<p>The APA Main menu helps you to load and save your data, manipulate random
costs, analyse the APA, edit the settings and show the help menu.</p>
<h2><a href="#Generate APA">Generate APA</a></h2>
<h2><a href="#Show Selection Screen">Selection Screen</a></h2>
<h2><a name="Mainmenu - File">Mainmenu - File</a></h2>
<p><a href="#Load File">Load File</a><a href="#Save File"><br>
Save File</a><a href="#Save as File"><br>
Save as.. File</a></p>
<h2>Mainmenu - Random costs</h2>
<p><a href="#Build random costs">Build random costs</a><a href="#Show Random Costs"><br>
Show random costs</a><a href="#Restricted costs"><br>
Restricted costs</a></p>
<h2>Mainmenu-Analyse</h2>
<p><a href="#APA Analyse">Analyse APA</a></p>
<p><img border="0" src="images/corel043.jpg" width="710" height="574"></p>
<p><a href="#Mainmenu - File">Go to Top</a></p>
<hr>
<h2><a name="Generate APA">Generate APA</a></h2>
<p>In order to generate the APA and show the APA Screen press button "APA
Grid".</p>
<h2><a name="Show Selection Screen">Show Selection Screen</a></h2>
<p>In order to switch to "APA Selection Screen" press button "APA
Selection Screen".</p>
<h2><a name="Load File">Load File</a></h2>
<p>To Load a File press "File-Open" and select your file.</p>
<p><img border="0" src="images/corel044.jpg" width="710" height="574"></p>
<p><img border="0" src="images/corel045.jpg" width="563" height="419"></p>
<p><a href="#Mainmenu - File">Go to Top</a></p>
<h2><a name="Save File">Save File</a></h2>
<p>To save the file press "File-Save".</p>
<p><img border="0" src="images/corel046.jpg" width="710" height="574"></p>
<p><a href="#Mainmenu - File">Go to Top</a></p>
<h2><a name="Save as File">Save as File</a></h2>
<p>Select "File-Save as ..." and choose a new file name.</p>
<p><img border="0" src="images/corel047.jpg" width="710" height="574"></p>
<p><img border="0" src="images/corel048.jpg" width="563" height="419"></p>
<p><a href="#Mainmenu - File">Go to Top</a></p>
<h2><a name="Build random costs">Build random costs</a></h2>
<p>In order to generate random costs press "Random costs-Build random
costs".</p>
<p><img border="0" src="images/corel049.jpg" width="710" height="574"></p>
<p><img border="0" src="images/corel050.jpg" width="696" height="480"></p>
<p><img border="0" src="images/corel051.jpg" width="328" height="310"></p>
<p><a href="#Mainmenu - File">Go to Top</a></p>
<h2><a name="Show Random Costs">Show Random Costs</a></h2>
- 470 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
<p>In order to show the random costs select "Random costs-Show random
costs".</p>
<p><img border="0" src="images/corel052.jpg" width="710" height="574"></p>
<p>It´s possible to edit the data and to export the data to Excel.</p>
<p><img border="0" src="images/corel050.jpg" width="696" height="480"></p>
<p><a href="#Mainmenu - File">Go to Top</a></p>
<h2><a name="Restricted costs">Restricted costs</a></h2>
<p>To change the ticker Restricted costs select "Random costs-Restricted
costs":</p>
<p><img border="0" src="images/corel053.jpg" width="710" height="574"></p>
<p><a href="#Mainmenu - File">Go to Top</a></p>
<h2><a name="APA Analyse">APA Analyse</a></h2>
<p>To show the "APA Analyse" window select "Analyse-Analyse
APA".</p>
<p><img border="0" src="images/corel055.jpg" width="710" height="574"></p>
<p><img border="0" src="images/corel054.jpg" width="696" height="480">
<p><a href="#Mainmenu - File">Go to Top</a></p>
</body>
</html>
12.2.6
APA_SELECTION_SCREEN.HTM
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
<meta http-equiv="Content-Language" content="de">
<title>APA Help - APA Selection Screen</title>
<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
<meta name="ProgId" content="FrontPage.Editor.Document">
<meta name="Microsoft Theme" content="blank 1111, default">
<meta name="Microsoft Border" content="tlb, default">
</head>
<body>
<p>The APA Selection Screen helps you to do block operations or/and requirement
operations.</p>
<h2><a name="Block operations">Block operations</a></h2>
<p><a href="#Add new requirement block">Add new requirement block<br>
</a><a href="#Edit requirement block">Edit requirement block<br>
</a><a href="#Delete requirement block">Delete requirement block<br>
</a><a href="#Select block">Select block<br>
</a><a href="#Deselect block">Deselect block<br>
</a><a href="#Select all">Select all<br>
</a><a href="#Deselect all">Deselect all<br>
</a><a href="#Delete all requirement blocks and cubes">Delete all requirement
blocks and cubes</a></p>
<h2>Requirements operations</h2>
<p><a href="#Add new requirement">Add new requirement<br>
</a><a href="#Edit requirement">Edit requirement<br>
</a><a href="#Delete requirement">Delete requirement<br>
</a></p>
<hr>
<h2><a name="Add new requirement block">Add new requirement block</a></h2>
<p>In order to add a new requirement block press the button "New req.
block" and enter the data. If you select "Add max. hierarchy level"
the maximum of all hierarchy levels is added.</p>
<p><img border="0" src="images/corel107.jpg" width="658" height="437"></p>
<p><img border="0" src="images/corel108.jpg" width="325" height="292"></p>
<p><img border="0" src="images/corel109.jpg" width="658" height="437"></p>
<h2><a name="Edit requirement block">Edit requirement block</a></h2>
<p>If you want to edit a requirement block select the block and press the button
"Edit req. block".</p>
<p><img border="0" src="images/corel110.jpg" width="658" height="437"></p>
<p><img border="0" src="images/corel111.jpg" width="325" height="292"></p>
<p><img border="0" src="images/corel112.jpg" width="658" height="437"></p>
<p><a href="#Block operations">Go to Top</a></p>
<h2><a name="Delete requirement block">Delete requirement block</a></h2>
<p>If you want to delete a requirement block select the block and press the
- 471 -
OPTIMIERUNG DER MATERIALISIERTEN SICHTEN IN EINEM DATAWAREHOUSE AUF DER
GRUNDLAGE DER AUS EINEM ERP-SYSTEM ÜBERNOMMEN OPERATIVEN DATEN
button "Delete req. block".</p>
<p><img border="0" src="images/corel113.jpg" width="658" height="437"></p>
<p><img border="0" src="images/corel114.jpg" width="658" height="437"></p>
<p><a href="#Block operations">Go to Top</a></p>
<h2><a name="Select block">Select block</a></h2>
<p>In order to select a requirement block for adding the block to the APA select
the block and press the button "Select".</p>
<p><img border="0" src="images/corel115.jpg" width="658" height="437"></p>
<p><img border="0" src="images/corel116.jpg" width="658" height="437"></p>
<p><a href="#Block operations">Go to Top</a></p>
<h2><a name="Deselect block">Deselect block</a></h2>
<p>If you want to deselect a requirement block press the button
"Deselect".</p>
<p><img border="0" src="images/corel117.jpg" width="658" height="437"></p>
<p><img border="0" src="images/corel118.jpg" width="658" height="437"></p>
<p><a href="#Block operations">Go to Top</a></p>
<h2><a name="Select all">Select all</a></h2>
<p>Press the Button "Select all" if you want to select all required
blocks.</p>
<p><img border="0" src="images/corel119.jpg" width="658" height="437"></p>
<p><img border="0" src="images/corel120.jpg" width="658" height="437"></p>
<p><a href="#Block operations">Go to Top</a></p>
<h2><a name="Deselect all">Deselect all</a></h2>
<p>Press the Button "Deselect all" if you want to deselect all
required blocks.</p>
<p><img border="0" src="images/corel121.jpg" width="658" height="437"></p>
<p><img border="0" src="images/corel122.jpg" width="658" height="437"></p>
<p><a href="#Block operations">Go to Top</a></p>
<h2><a name="Delete all requirement blocks and cubes">Delete all requirement
blocks and cubes</a></h2>
<p>In order to delete all requirement blocks and all required cubes in the APA
press "Delete all requirement blocks and cubes".</p>
<p><img border="0" src="images/corel131.jpg" width="658" height="437"></p>
<p><img border="0" src="images/corel132.jpg" width="471" height="129"></p>
<p><img border="0" src="images/corel133.jpg" width="125" height="110"></p>
<p><img border="0" src="images/corel134.jpg" width="658" height="437"></p>
<p><a href="#Block operations">Go to Top</a></p>
<h2><a name="Add new requirement">Add new requirement</a></h2>
<p>If you want to add a new requirement to an existing block press
"Insert".</p>
<p><img border="0" src="images/corel123.jpg" width="658" height="437"></p>
<p><img border="0" src="images/corel124.jpg" width="658" height="437"></p>
<p><img border="0" src="images/corel125.jpg" width="658" height="437"></p>
<p><a href="#Block operations">Go to Top</a></p>
<h2><a name="Edit requirement">Edit requirement</a></h2>
<p>If you want to edit a new requirement select the requirement and press
"Edit".
Then change the requirement and press "Accept".</p>
<p><img border="0" src="images/corel135.jpg" width="658" height="437"></p>
<p><img border="0" src="images/corel126.jpg" width="658" height="437"></p>
<p><img border="0" src="images/corel127.jpg" width="658" height="437"></p>
<p><img border="0" src="images/corel128.jpg" width="658" height="437"></p>
<p><a href="#Block operations">Go to Top</a></p>
<h2><a name="Delete requirement">Delete requirement</a></h2>
<p>If you want to delete a single requirement select the requirement and press
then button "Delete".</p>
<p><img border="0" src="images/corel129.jpg" width="658" height="437"></p>
<p><img border="0" src="images/corel130.jpg" width="658" height="437"></p>
<p><a href="#Block operations">Go to Top</a></body>
</html>
- 472 -