Beiträge

Script Logic Befehle in BPC 10.0

Die Skriptlogik (Script Logic) bildet das Pendant zu den FOX-Formeln in BI IP.
In diesem Beitrag stelle ich die wichtigsten Befehle vor. Wir fangen mit den Parametern TMVL, SET, DIM und Systemvariablen an.
Danach erläutere ich die folgenden Befehle:
WHEN / *ENDWHEN
REC
COMMIT
XDIM_MEMBERSET
XDIM_ADDMEMBERSET
XDIM_FILTER
XDIM_MAXMEMBERS
FOR / NEXT
SELECT
SELECTCASE
ADD
LOOKUP
DESTINATION_APP
*RUNALLOCATION

Sie können Ihren Code im Programm  UJK_SCRIPT_LOGIC_TESTER (Transaktion SE38) testen.

UJK_SCRIPT_LOGIC_TESTER

Skriptlogik Tester


TMVL
Der TMVL-Parameter gibt einen Zeitwert unter Berücksichtigung eines Offsets zurück. Diese Anweisung kann nur auf Werte von Basiselementen angewendet werden.
Die Syntax lautet

TMVL(offset, base_period)

Der Offset kann negativ oder positiv sein, dabei sind nur ganze Zahlen zulässig. Die Periode kann ein hart kodierter Wert wie 2013.12 sein. Sie können aber auch die Skriptvariable %TIME_SET% oder eine Daten Manager Eingabevariable wie $CURPER$ verwenden.
Wenn Sie Variablen wie z.B. %TIME_SET% verwenden, wird die erste Periode des Zeitsets für den negativen Offset und die letzte Periode für den positiven Offset verwendet.
Sie können den Parameter TMVL in der Datenselektion, FACTOR/EXPRESSION der REC Anweisung, FOR/NEXT-Schleifen und IS-Bedingungen in *WHEN verwenden.
So addiert zum Beispiel die folgende Script Logic die eingegebenen Werte aus Januar und Februar und schreibt diese auf März.

*WHEN TIME
*IS TMVL(-1,2013.02)
*REC(EXPRESSION=%VALUE%+[TIME].[2013.02],TIME=TMVL(1,2013.02))

Andere Verwendungsmöglichkeiten:

*XDIM_MEMBERSET TIME= TMVL(-1,2013.02),2013.02

*REC(FACTOR=1.1, TIME=TMVL(%COUNTER%,%TIME_SET%))


SET
Für jede Dimension steht ein implizites Schlüsselwort zur Verfügung. Das Schlüsselwort SET gibt den Satz von Elementen aus, der für eine bestimmte Dimension an die Logik Engine weitergegeben wird. Die Syntax lautet:

%{DimName}_SET%

Sie können das Schlüsselwort an jeder Stelle in der Skript Logik verwenden.

*XDIM_MEMBERSET PRODUCT = %PRODUCT_SET%
*XDIM_MEMBERSET TIME = %TIME_SET%

*WHEN TIME
*IS %TIME_SET%

*REC(EXPRESSION = %VALUE%/2)

Wenn Sie z.B. im EPM Context also 2013.TOTAL wird die Berechnung für die 12 Monate des Jahres 2013 durchgeführt.


DIM
Mit dem Schlüsselwort DIM ist es möglich technische Namen für alle Standard Dimensionen auszugeben.
Syntax:

%{DimType}_DIM%

%CATEGORY_DIM% als Variable gibt VERSION aus, wenn der technische Name der C-Dimension VERSION heißt.
Als gültige Dimensionstypen können verwendet werden:
ACCOUNT
CATEGORY
TIME
ENTITY
INTCO
CURRENCY
DATASRC


Systemvariablen
Folgende Systemvariablen können verwendet werden:
%USER% – gibt den aktuellen Business Planning and Consolidation Benutzer zurück
%APPSET% – gibt die aktuellen Business Planning and Consolidation Umgebung (Environment) zurück
%APP% – gibt das aktuelle Business Planning and Consolidation Modell (Cube) aus
%YEAR% – gibt das aktuelle Kalenderjahr zurück
Über %YEAR% können Sie die Elementwerte wie %YEAR%.TOTAL oder %YEAR%.Q1 ableiten. Sie können auch Offsets benutzen, z. B. %YEAR%(-2).TOTAL.


*WHEN / *ENDWHEN
*WHEN löst eine SQL Syntax aus. *WHEN Befehle werden genutzt, um die im Arbeitsspeicher befindliche Daten (standardmäßig beim Speichern gesendete Datensätze) auf bestimmte Datensätze einzuschränken.
Die Syntax lautet wie folgt:

*WHEN {criteria}
*IS [=]{value1}[,{value2},…] | <>{value}
*REC()
[*ELSE]
*ENDWHEN
*WHEN **IS * Wählt die gesamte Selektion aus
*WHEN ACCOUNT*IS "Preis" Wählt nur den Preis Account aus
*WHEN ACCOUNT.ACCTYPE*IS "INC","EXP" Wählt nur die Accounts mit dem ACCTYPE INC oder EXP aus
*IS "AVG", "END"*IS 10,20,30 Werte, die in doppelte Anführungszeichen eingeschlossen sind, werden als Strings behandelt. Werte ohne Anführungszeichen werden als numerische Werte angesehen.
*IS Wenn kein Operator spezifiziert ist, wird das Vorliegen eines Gleichheitszeichens angenommen (*IS = "AVG", "END").

Wenn ein ungleich-Zeichen (<>) verwendet wird, kann nur ein Wert übermittelt werden. *IS <> "AVG".  Daher ist die Syntax *IS <> 2,3,4 ungültig!

Zum Beispiel: KPI5 = 2*KPI1

*WHEN ACCOUNT
*IS "KPI1"
*REC(FACTOR=2,ACCOUNT="KPI5")
*ENDWHEN
*COMMIT

Das folgende Beispiel summiert KPI1 und KPI2, anschließend erfolgt eine Multiplikation mit 2

KPI5 = (KPI1+KPI2) * 2
*WHEN ACCOUNT
*IS KPI1, KPI2
//Summiert KPI1 und KPI2
*REC(FACTOR=2,ACCOUNT="KPI5")
//KPI5 = (KPI1+KPI2)*2
*ENDWHEN
*COMMIT


*REC
Die *REC()-Anweisung erstellt einen neuen Datensatz wenn die festgelegten Kriterien erfüllt sind. REC muss immer gemeinsam mit WHEN / IS / ENDWHEN verwendet werden.
Die Parameter der Funktion REC( ) geben an, was vom Originaldatensatz zu ändern ist. Jedes Dimensionselement kann mit folgender Syntax geändert werden: {dim}={"member"}

*REC[([FACTOR|EXPRESSION={Expression}[,{dim1}= {"member"},{dim2}=…])]

Zum Beispiel kopiert dieses Skript die Istdaten für 2013 in die Planung und erhöht diese um 10%.

*XDIM_MEMBERSET CATEGORY = IST
*WHEN TIME.YEAR
*IS "2013"
*REC(FACTOR = 1.1, CATEGORY="PLAN")
*ENDWHEN

Mit FACTOR können nur Multiplikationen durchgeführt werden. Mit EXPRESSION können Sie auch andere arithmetische Funktionen verwenden: +, -, /.
Jeder Quelldatensatz kann so viele Sätze wie gewünscht generieren. Dieses Skript legt im Cube EUR-, CAD- und GBP-Werte an. Zuvor wird der Wert von KPI1 wird in die lokale Variable %VALUE% geschrieben.

*WHEN ACCOUNT
*IS "KPI1"
//Der Wert von KPI1 wird in die lokale Variable %VALUE% geschrieben.
*REC(EXPRESSION=%VALUE%/1.5098, RPTCURRENCY="EUR")
*REC(EXPRESSION=%VALUE%/1.0666, RPTCURRENCY="CAD")
*REC(EXPRESSION=%VALUE%/1.9183, RPTCURRENCY="GBP")
*ENDWHEN

Der Member(Ausprägung) muss in Anführungszeichen gesetzt werden. Es können auch Attribute ausgewählt werden.

Das folgende Coding summiert über alle Account mit dem Attribut ACCTYPE EXP und teilt die Summe durch den Wert von KPI1. Das Ergebnis wird in KPI5 geschrieben.

*WHEN ACCOUNT.ACCTYPE
*IS EXP
// Summiere über alle Accounts mit Attribut ACCTYPE = EXP
*REC(EXPRESSION = %VALUE%/[ACCOUNT].[KPI1], ACCOUNT = "KPI5")
// Teile die Summe durch KPI1
*ENDWHEN
*COMMIT


*COMMIT
Standardmäßig werden die Berechnungen im Arbeitsspeicher durchgeführt. *COMMIT schreibt die berechneten Werte in die Datenbank. Es kann notwendig sein, Ergebnisse einer Formel zwischenzuspeichern um später in derselben Logik auf das Ergebnis zugreifen zu können. Beachten Sie jedoch, dass sich die umfangreiche Kommunikation zwischen der Datenbank und der Skript Logik Engine negativ auf die Performance auswirken kann. Daher sollte die Anzahl der *COMMIT Anweisungen auf ein Minimum reduziert werden.


*XDIM_MEMBERSET
Standardmäßig werden die Kalkulationen nur auf Datensätzen ausgeführt die sich zu dem Moment im Arbeitsspeicher befinden. Der Befehl *XDIM_MEMBERSET liest Daten in den Speicher, unabhängig davon ob diese geändert wurden oder nicht (eXpand selection). Damit wird der Datenumfang für die Anwendung der Geschäftslogik festgelegt. Dabei wird der vom Benutzer übergebene Bereich überschrieben.
Syntax

*XDIM_MEMBERSET {Dimension} = {Members Set}
*XDIM_MEMBERSET {Dimension}<>{Members Set}

Ein Beispiel – Account KPI1 und KPI2 werden in den Speicher gelesen. Wenn auch KPI3 als Delta kommt, wird dieser Datensatz nicht beachtet. Die Summe wird auf KPI5 geschrieben.

*XDIM_MEMBERSET ACCOUNT=KPI1,KPI2
*WHEN ACCOUNT
*IS *
*REC(ACCOUNT="KPI5")
*ENDWHEN
*COMMIT

Gültige Anwendungsfälle sind:

*XDIM_MEMBERSET ACCOUNT=KPI1
*XDIM_MEMBERSET ACCOUNT=KPI1,KPI2
*XDIM_MEMBERSET ACCOUNT=bas(KPI_NODE) //alle Elemente der Hierarchie KPI_NODE
*XDIM_MEMBERSET ACCOUNT= <ALL>  //einschließlich der übergeordeneten Elemente
*XDIM_MEMBERSET ACCOUNT <> KPI5 //außer KPI5

Sie können bas() nicht mit einem anderen Elementsatz kombinieren.
*XDIM_MEMBERSET P_ACCT = bas(KPI_NODE), KPI6 //Ungültige Syntax, KPI6 ist in KPI_NODE2
Verwenden Sie *XDIM_ADDMEMBERSET, um dem Umfang des bereits durch bas() definierten Elementsatzes weitere Elemente hinzuzufügen.
Im Gegensatz zu *WHEN kann *XDIM_MEMBERSET nicht mit Attributen verwendet werden. Diese Funktionalität wird durch *XDIM_FILTER und *SELECT abgedeckt.


*XDIM_ADDMEMBERSET
Mit *XDIM_ADDMEMBERSET können Sie einen spezifischen Satz von Elementen mit den Elementen zusammenführen, die in dem Bereich übergeben wurden, für den die Logik ausgeführt werden soll. Der Unterschied zu *XDIM_MEMBERSET besteht darin, dass *XDIM_MEMBERSET den vom Benutzer übergebenen Bereich neu definiert, während XDIM_ADDMEMBERSET einen Satz dem übergebenen Bereich hinzufügt.

Syntax

*XDIM_ADDMEMBERSET {dimension} = {members set}

Beispiel

*XDIM_MEMBERSET ACCOUNT=bas(KPI_NODE)
*XDIM_ADDMEMBERSET ACCOUNT = KPI6
[TIME].[#2014.DEC] = [TIME].[2013.DEC] * 1.2
*COMMIT

Im obigen Beispiel werden dem Element KPI6 alle untergeordneten Elemente von KPI_NODE hinzugefügt.

ACCOUNT Dimension Hierarchie

Struktur der ACCOUNT Dimension


*XDIM_FILTER
*XDIM_FILTER liest alle Elemente in den Speicher, die die angegebene Bedingung erfüllen.
Syntax:

*XDIM_FILTER {dimension} = {members set}

So liest z.B. die folgende Anweisung alle Accounts mit dem Account Typ INC in den Speicher.

*XDIM_FILTER ACCOUNT = [ACCOUNT].properties("ACCTYPE") = "INC"

Typischerweise wird dieser Befehl genutzt um eine Anzahl von Ausprägungen gegen bestimmte Attribute zu filtern. Dabei werden doppelte Sätze (z.B. bei mehreren Hierarchien) automatisch entfernt.
Beispiel:

*XDIM_MEMBERSET ACCOUNT=bas(KPI_NODE)
*XDIM_FILTER TIME = [TIME].properties("MONTHNUM") = "2"

*WHEN ACCOUNT
    *IS *
    *REC(ACCOUNT = "KPI6")
*ENDWHEN
*COMMIT

Der Quelltext in diesem Beispiel schreibt nur Datensätze aus dem Monat Februar in KPI6. Aber Achtung! Dabei werden alle Jahre berücksichtigt.


*XDIM_MAXMEMBERS
Falls die Zahl der zu verarbeitenden Datensätze zu groß ausfällt, kann dies die Performance stark beeinträchtigen. Die Verarbeitung zu vieler Daten im Speicher kann dazu führen, dass kein freier Speicherplatz mehr vorhanden ist. Dabei kann ABAP-Dump TSV_TNEW_PAGE_ALLOC_FAILED eintreten. Um es zu verhindern, können Sie den Vorgang in mehrere Pakete aufteilen und diese mittels der folgenden Syntax nacheinander verarbeiten:

Syntax

*XDIM_MAXMEMBERS {dimension} = {max number of members}

In dem folgenden Beispiel wird die Jahresprognose initial in 2013.JAN und Version FCST_LOAD geladen. Das Skript verteilt die Daten gleichmäßig auf alle Perioden des Jahres 2013. Die Script Logic Engine wird beim Lesen die Daten nach ACCOUNT-Elementen aufteilen, wobei jedes Paket maximal fünf ACCOUNT-Elemente enthält, bis das Ende der ACCOUNT-Dimensionselemente erreicht ist.

*XDIM_MEMBERSET TIME = 2013.JAN
*XDIM_MEMBERSET CATEGORY = FCST_LOAD
*XDIM_MAXMEMBERS ACCOUNT  = 5
*RUNALLOCATION
*FACTOR=1/12
*DIM TIME WHAT = 2013.JAN; WHERE = BAS(2013.TOTAL);
*DIM CATEGORY WHAT = FCST_LOAD; WHERE = FORECAST;
*ENDALLOCATION


*FOR / *NEXT
Sie können Schleifen in Form von *FOR/*NEXT Befehlen verwenden um für einen Satz von Elementen bestimmte Schritte zu wiederholen. Die Elementsätze können direkt in der FOR-Anweisung oder über eine Variable bereitgestellt werden. Diese Variable kann über *SELECT gefüllt werden.
Die Syntax sieht wie folgt aus:

*FOR {Variable1} = {Satz1} [ AND {Variable2={Satz2}]
Anweisung
*NEXT

Im folgenden Beispiel werden die Prognosedaten, die in Januar 2013 geladen wurden gleichmäßig über alle Perioden in Q1 verteilt.

*XDIM_MEMBERSET TIME = 2013.JAN
*XDIM_MEMBERSET CATEGORY = Q1FCST_LOAD
*FOR %Q1% = 2013.JAN, 2013.FEB, 2013.MAR
*RUNALLOCATION
*FACTOR=1/3
*DIM TIME WHAT = 2013.JAN; WHERE = %Q1%;
*DIM CATEGORY WHAT=Q1FCST_LOAD; WHERE=FCST;
*ENDALLOCATION
*NEXT

Das nächste Beispiel nimmt den Januarwert aus KPI1 und geht in einer Schleife über alle Accounts. Das System summiert den Januar- zu dem Februarwert des jeweiligen Accounts und schreibt die Summe für den entsprechenden Account auf den März.

*XDIM_MEMBERSET TIME=2013.01,2013.02
*XDIM_MEMBERSET ACCOUNT = KPI1

*WHEN ACCOUNT
*IS *
*WHEN TIME
*IS "2013.01"

*FOR %KPI% = KPI1, KPI2, KPI3, KPI4, KPI5
*REC(EXPRESSION=%VALUE%+([ACCOUNT].[%KPI%],[TIME].[2013.02]),CATEGORY=PLAN,ACCOUNT=%KPI%,TIME=2013.03)
*NEXT

*ENDWHEN
*ENDWHEN
*COMMIT

Das *FOR/*NEXT Statement wird vom System wie folgt interpretiert.

*REC(EXPRESSION=%VALUE%+([ACCOUNT].[KPI1],[TIME].[2013.02]),CATEGORY=PLAN,ACCOUNT=KPI1,TIME=2013.03)
*REC(EXPRESSION=%VALUE%+([ACCOUNT].[KPI2],[TIME].[2013.02]),CATEGORY=PLAN,ACCOUNT=KPI2,TIME=2013.03)
*REC(EXPRESSION=%VALUE%+([ACCOUNT].[KPI3],[TIME].[2013.02]),CATEGORY=PLAN,ACCOUNT=KPI3,TIME=2013.03)
*REC(EXPRESSION=%VALUE%+([ACCOUNT].[KPI4],[TIME].[2013.02]),CATEGORY=PLAN,ACCOUNT=KPI4,TIME=2013.03)
*REC(EXPRESSION=%VALUE%+([ACCOUNT].[KPI5],[TIME].[2013.02]),CATEGORY=PLAN,ACCOUNT=KPI5,TIME=2013.03)


*SELECT
Das *SELECT Statement geht auf die SQL Tabellen und ruft eine Liste von Elementen aus einer Dimension ab. Diese werden in einer Variablen gespeichert um sie später an beliebiger Stelle in der Logik einsetzen zu können. Dies ermöglicht mehr Flexibilität im Vergleich zur *XDIM_FILTER Anweisung.
Die Syntax lautet wie folgt:

*SELECT ({Variable}, {[Was]}, {Quelldimension}, {Wo})

Mit der folgenden Anweisung kann der Benutzer die IDs aller Elemente in der ACCOUNT Dimension abrufen, deren Eigenschaft ACCTYPE den Wert EXP hat.

*SELECT(%SELVAR%, "[ID]",ACCOUNT,"ACCTYPE" = "EXP")
*XDIM_MEMBERSET ACCOUNT = %SELVAR%

Die *SELECT Anweisung füllt die Variable %SELVAR% mit der in der aktuellen Anwendung definierten Liste der Expense Konten. Anschließend wird der Inhalt der resultierenden Variable in der *XDIM_MEMBERSET Anweisung verwendet. Die Variable kann auch in *FOR verwendet werden.
Sie können den *SELECT Befehl nur mit einem Gleichheitszeichen (=) verwendet werden. Ungleichzeichen (<>) können nicht verwendet werden. Außerdem kann die Anweisung nicht zur Kombination mehrerer Filterkriterien mit AND– oder OR-Schlüsselwörtern genutzt werden.
Beachten Sie, dass die Variablen während der Kompilierung definiert werden, nicht zur Laufzeit. Wenn also neue Elemente hinzugefügt werden, ist es nötig die Logik erneut zu validieren. Um es zu umgehen können Sie die Skript Logik in einer LGF statt LGX Datei aufrufen. Diese wird zur Laufzeit validiert und berücksichtigt somit die Änderungen an der Dimension.

Im folgenden Beispiel werden mehrere KPIs beplant. Es werden aber nur die KPIs mit dem ACCTYPE „EXP“ berücksichtigt. Zuerst werden die Werte mit 1.1 multipliziert und auf den Februar geschrieben. Nach der Umwertung wird der Januar-Wert von KPI1 mit der jeweiligen Kennzahl summiert. Das Ergebnis wird für jede KPI auf März geschrieben.

*XDIM_MEMBERSET TIME=2013.01
*XDIM_MEMBERSET CATEGORY=PLAN
*SELECT(%SELVAR%, "[ID]",ACCOUNT,"ACCTYPE" = "EXP")
*XDIM_MEMBERSET ACCOUNT = %SELVAR%

*WHEN CATEGORY
*IS "PLAN"
*REC(FACTOR=1.1,TIME="2013.02")
*ENDWHEN
*COMMIT

*XDIM_MEMBERSET TIME=2013.01,2013.02
*XDIM_MEMBERSET ACCOUNT = KPI1

*WHEN ACCOUNT
*IS *
*WHEN TIME
*IS "2013.01"

*FOR %KPI% = %SELVAR%

*REC(EXPRESSION=%VALUE%+([ACCOUNT].[%KPI%],[TIME].[2013.02]),CATEGORY=PLAN,ACCOUNT=%KPI%,TIME=2013.03)
*NEXT
*ENDWHEN
*ENDWHEN
*COMMIT


*SELECTCASE
*SELECTCASE ist eine Alternative zu IIF() MDX Befehlen und wird im Hintergrund als eine IIF Anweisung ausgeführt. Die Syntax ist kürzer, aber die Performance Probleme von MDX bleiben. Beachten Sie, dass *WHEN/*ENDWHEN eine bessere Performance liefert. SELECTCASE-Strukturen können zurzeit nicht geschachtelt werden.

Die Syntax lautet wie folgt:

*SELECTCASE {expression}
*CASE {value1}[,{value2},…]
{formulas}
[*CASE {value1}[,{value2},…]
{formulas}
[*CASEELSE]
{formulas}
*ENDSELECT

Das folgende Logic Script wählt die Accounts anhand von der Eigenschaft ACCTYPE aus. Wenn es sich um EXP-Konten handelt werden die Januar-Werte mit dem Faktor 1,1 umgewertet und auf den Februar geschrieben. Im Falle von INC-Konten beträgt der Umwertungsfaktor 1,2.

*XDIM_MEMBERSET TIME=2011.01,2011.02
*XDIM_MEMBERSET CATEGORY=BUDGET
*XDIM_MEMBERSET INPUTCURRENCY=EUR
*XDIM_MEMBERSET ENTITY=STORE
*XDIM_MEMBERSET PRODUCT2=PRODUCT

*SELECTCASE [ACCOUNT].CURRENTMEMBER.PROPERTIES("ACCTYPE")

*CASE EXP
[TIME].[#2011.02] = [TIME].[2011.01]*1.1

*CASE INC
[TIME].[#2011.02] = [TIME].[2011.01]*1.2

*ENDSELECT


*ADD
Mit dieser Struktur können Sie einen Satz an Elementen zu einem berechneten Element kumulieren. Diese Elemente werden in einem durch Kommas getrennten Bereich angegeben. Der Bereich kann auch durch eine *SELECT( )-Anweisung dynamisch abgeleitet werden. Die ADD-Anweisung kann nur eine Formel ausführen. Diese muss eine MDX Formel sein.

Die Syntax lautet wie folgt:

*ADD {variable} = {set}
{formula}
*ENDADD

Die folgende Logik summiert die KPIs eins bis vier und dividiert die Summe durch KPI1. Das Ergebnis wird auf KPI5 geschrieben.

*ADD %ACC%=[KPI1],[KPI2],[KPI3],[KPI4]
[#KPI5]= %ACC%/[KPI1]
*ENDADD

Wenn Sie eine Division durch Null ausführen ersetzt die Skript Logik den Fehler automatisch durch Null.


*LOOKUP
Oft ist es nötig auf Werte zuzugreifen die außerhalb von der Selektion liegen. Mit *LOOKUP können Sie Werte aus anderen Modellen (Cubes) hinzulesen. Sie können auch Werte aus dem aktuellen Cube hinzulesen, die außerhalb des momentanen Datenumfangs liegen. Allerdings können Sie nicht mehrere Kennzahlen innerhalb eines einzelnen LOOKUP durch Zuordnen mehrerer Lookup-IDs lesen.

Syntax:

*LOOKUP {App}
*DIM [{LookupID}:]{DimensionName}="Value" | {CallingDimensionName}[.{Property}]
*DIM MEASURES=”MeasureName”
*ENDLOOKUP

Die Lookup ID wird wie folgt festgelegt:
*DIM RATEUSD:INPUTCURRENCY="USD"
Dabei ist RATEUSD die LookUp ID die in der weiteren Skript Logik verwendet werden kann.

Folgende Zahlen sind im Rates-Cube.

CATEGORY INPUTCURRENCY R_ACCOUNT R_ENTITY TIME SignData
FORECAST EUR AVG GLOBAL 2013.01

1

FORECAST USD AVG GLOBAL 2013.01

1,3625

FORECAST CHF AVG GLOBAL 2013.01

1,2258

FORECAST GBP AVG GLOBAL 2013.01

0,8314

Im folgenden Beispiel wird der Umrechnungskurs für USD aus dem Rates Cube gelesen. Die Planwerte in EUR werden mit dem Rechnungskurs (Lookup ID RATEUSD) multipliziert und auf die Währung USD geschrieben. (100 EUR = 136,25 USD)

*XDIM_MEMBERSET CATEGORY=FORECAST
*XDIM_MEMBERSET ENTITY=STORE
*XDIM_MEMBERSET INPUTCURRENCY=EUR
*XDIM_MEMBERSET PRODUCT2=PRODUCT
*XDIM_MEMBERSET ACCOUNT= BAS(KPI_NODE)
*XDIM_MEMBERSET TIME= 2013.01

*LOOKUP Rates
*DIM TIME="2013.01"
*DIM CATEGORY="FORECAST"
*DIM R_ACCOUNT="AVG"
*DIM R_ENTITY="Global"
*DIM RATEUSD:INPUTCURRENCY="USD"
*DIM MEASURES="PERIODIC"
*ENDLOOKUP

*WHEN CATEGORY
*IS FORECAST
*REC(EXPRESSION=%VALUE%*LOOKUP(RATEUSD), INPUTCURRENCY=USD)
*ENDWHEN


*DESTINATION_APP
Die Anweisung *DESTINATION_APP erlaubt es Ihnen die Ergebnisse einer Berechnung in einer anderen Anwendung (Cube) zu speichern.
Syntax

*DESTINATION_APP = {Anwendungsname}

Wenn der Befehl *DESTINATION_APP das erste Mal mitten im Skript erscheint, werden alle noch zu schreibenden Daten der Skriptlogikdatei in die referenzierte Zielanwendung geschrieben. Vor dem Auftreten von *DESTINATION_APP Syntax werden alle Daten in die Anwendung geschrieben, in der das Skript aktuell ausgeführt wird.
Im folgenden Beispiel zeige ich wie Sie die Ist-Werte (Version ACTUAL) von einem Ist-Cube in den Plan-Cube PLANNING kopieren können.

*XDIM_MEMBERSET TIME = 2013.01
*XDIM_MEMBERSET CATEGORY =ACTUAL

*DESTINATION_APP = PLANNING

*WHEN CATEGORY
*IS "ACTUAL"
*REC(EXPRESSION=%VALUE%)
*ENDWHEN

Dabei können Sie Dimensionen entfernen, hinzufügen oder umbenennen wenn der Aufbau der Anwendungen nicht übereinstimmt.
In der Regel hat die Zielanwendung nur wenige Dimensionen mit der Quellanwendung gemeinsam. In diesem Fall können Sie die fehlenden Dimensionen aus den ursprünglichen Datensätzen mit der Anweisung *SKIP_DIM überspringen.

*SKIP_DIM= {Dimensionsname}[,{Dimensionsname},…]

Das Schlüsselwort SKIP_DIM ist obligatorisch falls die ursprüngliche Anwendung Dimensionen besitzt, die in der Zielanwendung nicht vorhanden sind. In diesem Fall kann eine Validierung ohne das Schlüsselwort SKIP_DIM nicht stattfinden!

Wenn aber die Zielanwendung Dimensionen hat, die in der Quellanwendung nicht vorhanden sind, können diese den übermittelten Sätzen hinzugefügt werden. Verwenden Sie dazu die *ADD_DIM Anweisung.

*ADD_DIM {Dimensionsname}={Wert}[,{Dimensionsname}={Wert},…]

Wenn die jeweiligen Anwendungen semantisch gleiche Dimensionen aufweisen, diese jedoch unterschiedliche Namen tragen, können Sie mit *RENAME_DIM den Namen der Dimensionen ändern.

*RENAME_DIM {Dimensionsname}={Wert}[,{Dimensionsname}={Wert},…]

Lassen Sie uns das oben angeführte Beispiel erweitern.
Die Dimension ACTIVITY ist nicht in dem PLANNING Cube enthalten und wird übersprungen. Allerdings enthält der Plan-Cube die Dimensionen PRODUCT, MARKET und AUDITTRAIL. Die Daten werden auf leere Dimensionen PRODUCT und MARKET NONE (Raute in BW IP) geschrieben. Gleichzeitig wird die Dimension AUDITTRAIL fix auf INPUT gesetzt. Die Werte der Dimension P_ACCT werden auf die Dimension ACCOUNT geschrieben. Außerdem werden die Daten unter der Version „PLAN“ hinterlegt (CATEGORY = PLAN).

    *XDIM_MEMBERSET TIME = 2013.01
    *XDIM_MEMBERSET CATEGORY =ACTUAL

    *DESTINATION_APP = PLANNING
    *SKIP_DIM = ACTIVITY
    *ADD_DIM PRODUCT = NONE, MARKET = NONE, AUDITTRAIL = INPUT
    *RENAME_DIM  P_ACCT = ACCOUNT

    *WHEN CATEGORY
    *IS "ACTUAL"
    *REC(EXPRESSION=%VALUE%, CATEGORY = PLAN)
    *ENDWHEN


*RUNALLOCATION
Mit der Allokation können Sie Daten anhand des angegebenen Faktors verteilen. Diese Funktion wird oft in der Top-Down Planung verwendet.

Syntax

*RUNALLOCATION
*FACTOR=<driver>
*DIM P_ACCT WHAT=<soure>; WHERE=<target>; USING=<distribution key>; [TOTAL=<distribution key>]
*DIM <other dimensions>
*ENDALLOCATION

Zum Beispiel:

*XDIM_MEMBERSET P_ACCT = BAS(ALLOCATION_NODE)
*XDIM_MEMBERSET ENTITY = BAS(NODE_ALLOCATION)

*RUNALLOCATION
*FACTOR = USING/TOTAL

*DIM ENTITY          WHAT = BAS(NODE_SENDER);  WHERE = BAS(NODE_RECEIVER);  USING = <<<;            TOTAL = <<<;
*DIM P_ACCT          WHAT = ORIGINAL_ACCOUNT;  WHERE = <<<;                 USING = ALLOC_KEY_SQM;  TOTAL = <<<;
*DIM CATEGORY        WHAT = FORECAST;          WHERE = <<<;                 USING = <<<;            TOTAL = <<<;
*DIM PRODUCT2        WHAT = NONE;              WHERE = <<<;                 USING = <<<;            TOTAL = <<<;
*DIM INPUTCURRENCY   WHAT = EUR;               WHERE = <<<;                 USING = <<<;            TOTAL = <<<;

*ENDALLOCATION
*COMMIT

Die Syntax kann beliebig komplex ausfallen, daher versuche ich diese Anweisung anhand eines generischen Beispiels von SAP zu erklären. Für eine detailliertere Beschreibung verweise ich an SAP Hilfe.
Im Grunde ist es ganz einfach. Die Daten eines Quellbereichs (WHAT) werden anhand des angegebenen Faktors (USING) auf einen Zielbereich (WHERE) verteilt.

RUNALLOCATION Verteilung

RUNALLOCATION Schema

In unserem Beispiel verteilen wir die Daten vom Sender auf zwei Receiver. Als Verteilungsschlüssel dient das Konto ALLOC_KEY_SQM. Wenn Sie den Verteilungsschlüssel in Prozent definieren wollen verwenden Sie *FACTOR = USING/100.

Allocation

Distribution – davor

Dem Receiver 1 werden 1000 EUR zugewiesen (3000 * 100/300 bzw. 1/3) und Receiver 2 erhält 2000 EUR ( 2000 * 200/300).

Allocation after

Distribution – danach

Wenn Sie den ursprünglichen Wert löschen wollen, fügen Sie die folgenden Zeilen hinzu.

*ENDALLOCATION

*WHEN ENTITY
*IS SENDER
*REC(EXPRESSION = 0,P_ACCT = ORIGINAL_ACCOUNT)
*ENDWHEN

*COMMIT

Im folgenden Beispiel werden die auf einer höheren Aggregationsstufe geplanten Werte anhand von Ist-Daten verteilt. Leider ist es zurzeit nicht möglich, auf die Referenzdaten in einem anderen Model (Cube) zuzugreifen. Daher müssen Sie die Daten zuerst auf den Plan-Cube kopieren.

Referenzdaten davor

Verteilung nach Referenzdaten – davor

*RUNALLOCATION
*FACTOR = USING/TOTAL

*DIM ACCOUNT         WHAT = SAAMO;    WHERE = <<<;       USING = <<<;             TOTAL = <<<;
*DIM CATEGORY        WHAT = PLAN;     WHERE = <<<;       USING = ACTUAL;          TOTAL = <<<;
*DIM COMPCODE        WHAT = 1000;     WHERE = <<<;       USING = <<<;             TOTAL = <<<;
*DIM SAORG           WHAT = 1000;     WHERE = <<<;       USING = <<<;             TOTAL = <<<;
*DIM SAOFF           WHAT = NONE;     WHERE = BAS(ALL);  USING = BAS(ALL);        TOTAL = <<<;
*DIM DICHA           WHAT = NONE;     WHERE = BAS(ALL);  USING = BAS(ALL);        TOTAL = <<<;
*DIM PRODUCT         WHAT = NONE;     WHERE = BAS(ALL);  USING = BAS(ALL);        TOTAL = <<<;
*DIM INPUTCURRENCY   WHAT = EUR;      WHERE = <<<;       USING = <<<;             TOTAL = <<<;
*DIM TIME            WHAT = 2014.INP; WHERE = <<<;       USING = BAS(2013.TOTAL); TOTAL = <<<;

*ENDALLOCATION
*COMMIT
Referenzdaten danach

Verteilung nach Referenzdaten – danach

Quellen:
SAP Hilfe
SAP Hilfe *RUNALLOCATION

Falls Ihnen dieser Beitrag weitergeholfen hat, wäre es eine sehr nette Anerkennung meiner Arbeit wenn Sie z.B. Ihre Bücher über Amazon bestellen würden. Wenn Sie ein Produkt kaufen, erhalte ich dafür eine Provision. Für Sie ändert sich am Preis des Produktes gar nichts. Ich möchte mich an dieser Stelle jetzt schon für Ihre Unterstützung bedanken.

Denis Reis ist Business Intelligence Consultant bei Dahlbeer und gibt als Buchautor sein Wissen rund um den SAP Projektalltag weiter. Des Weiteren unterrichtet er Projektmanagement und Controlling an der Wiesbaden Business School. Der aus Düsseldorf stammende Familienmensch zählt zu denjenigen, die auf komplizierte Darstellungen verzichten und das Ganze auf den Punkt bringen.