Seitenhistorie
Regeln sind Kontrollstrukturen, die es Ihnen ermöglichen, bedingte Ausführungen zu erstellen.
In Regeln definieren Sie Spalten und Zeilen, wobei die Spalten Bedingungen mit Werten vorgeben.
Jede Zeile definiert dagegen Werte für die Spaltenbedingungen und einen Rückgabewert.
Der Rückgabewert der Zeile, in der alle Werte mit den Spaltenbedingungen übereinstimmen, ist der Wert der Regel.
abhängig von Bedingungen unterschiedliche Werte annehmen können. Eine Regel enthält also eine oder mehrere Bedingungen und eine oder mehrere Auswahlmöglichkeiten. Die Auswahlmöglichkeit, die alle Bedingungen erfüllt, liefert den Rückgabewert der Regel.
Dazu gibt es in einer Regel Spalten und Zeilen: Die Spalten sind die Bedingungen der Regel. Jede Spalte enthält einen Wert, die Bedingung dieser Spalte. Die Zeilen sind die alternativen Auswahlmöglichkeiten für die Regel. Jede Zeile gibt pro Spalte einen Wert an. Die Zeile, in der in jeder Spalte der Zeilenwert die Bedingung der Spalte erfüllt, ist die gültige Auswahl für die Regel und ihr Rückgabewert der Wert der Regel. Dieser kann einen beliebigen Datentyp haben (Datentypen: Siehe Variable)Der Wert der Regel kann dabei jeden Datentyp haben. Eine Regel kann auch eine EVAL-Anweisung zurückgeben.
Abbildung A: Aufbau einer Regel
/ einen Verweis auf eine Ressource zurückgeben. Das Symbol für Regeln im R-S ist .
Aufbau einer Regel im R-S
Abbildung A
In Abb. A sehen Sie den Aufbau einer Regel mit Spalten (Abb. A (1)) und Zeilen (Abb. A (2)). Eine Spalte definiert genau einen Wert als Bedingung. In Abb. A sind das:
Spaltenname |
---|
Erstzulassung |
---|
Modell |
---|
Preis |
---|
Will_Verkaufen |
---|
PS | |
---|---|
Wert (Bedingung) | 01.01.2013 |
100
RS5 |
TRUE
75. |
500 |
Hallo
TRUE |
450 |
Diese Spaltenwerte sind die Bedingungen der Regel, auf die die Zeilen in den entsprechenden Spalten geprüft werden. Der Wert einer Spalte kann einen der folgenden Datentypen haben (die in Abb. A alle verwendet wurden):
...
Panel | ||||||
---|---|---|---|---|---|---|
| ||||||
|
...
|
Spalten stellen die Bedingungen der Regel dar. Der Wert einer Spalte ist die Spaltenbedingung in dieser Spalte.
Eine Zeile erfüllt die Bedingung in einer Spalte, wenn ihr Wert in der Spalte mit der Spaltenbedingung übereinstimmt.
Erfüllt eine Zeile die Bedingungen aller Spalten, trifft die Regel auf die Zeile zu und ihr Rückgabewert ist der Wert der Regel.
|
Scroll Pagebreak |
---|
In Abb. A ist Zeile #3 die gültige Auswahl für die Regel, da alle Werte in der Zeile identisch zum jeweiligen Spaltenwert sind
...
. Die Regel hat also den
...
Wert ${Angebot_3}
(3) . Wird die Regel aufgerufen, so ist das Ergebnis:
Codeblock | ||
---|---|---|
| ||
Aufruf (EVAL-Anweisung): ${NameDerRegel}
Rückgabewert: ${Angebot_3}
Endwert: Verweis auf "Angebot_3" |
Mit ${Angebot_3}
wird eine Ressource mit dem Namen Angebot_3
zurückgegeben, in diesem Fall z.B. eine binäre Ressource, die das entsprechende Angebot als Bild enthält. Die Verwendung dynamischer Anweisungen wird im Folgenden vorgestellt.
Info |
---|
Der Operator * ist immer wahr. Enthält eine Zeile also in einer Spalte den Wert '*', so erfüllt die Zeile die Bedingung dieser Spalte immer, unabhängig von der Spaltenbedingung. Mehr dazu im im Abschnitt über boolsche Operatoren. |
EVAL-Anweisungen und dynamische Einbindung innerhalb einer Regel
Im oberen Abschnitt wurden in der Regel, abgesehen von den Rückgabewerten, nur statische Werte verwendet. In der Praxis werden Sie in Regeln jedoch fast immer auch dynamische Werte in Spalten und Zeilen verwenden, denn i n einer Regel, in der alle Werte schon statisch feststehen, steht auch der Rückgabewert der Regel schon fest - Man könnte den Wert auch einfach einer Variablen zuweisen. Der Zweck von Regeln besteht aber darin, eine Möglichkeit zu schaffen, für unterschiedliche Eingangswerte ein unterschiedliches Verhalten zu implementieren.
Abbildung B
Scroll Pagebreak
Typischerweise werden in einer Regel Datenstrom-Variablen verarbeitet, z.B. um dynamisch eine Ressource anzuwählen:
Codeblock | ||
---|---|---|
| ||
Je nach Nationalität des Kunden soll dessen Nationalflagge angezeigt werden. Die Nationalität des Kunden wird durch die Datenstrom-Variable DS.NATIONALITY geliefert - Bei jedem Kunden individuell.
Um abhängig von DS.NATIONALITY die richtige Ressource auszusuchen, benötigt man eine Regel.
Diese liefert, je nach Wert von DS.NATIONALITY, die richtige Ressource zurück. Ruft man die Regel auf, erhält man automatisch die richtige Ressource. |
Mögliche Werte von DS.NATIONALITY
:
Wert | GER | CH | AUT |
---|---|---|---|
Kunde kommt aus | Deutschland | Schweiz | Österreich |
Binäre Ressourcen, die die Flaggen enthalten:
Name der Ressource | ger_flag | ch_flag | at_flag |
---|---|---|---|
Inhalt |
Scroll Pagebreak |
---|
Dazugehörige Regel:
Abbildung C
In Abb. C wird der Spaltenwert durch die dynamische Einbindung der Datenstrom-Variablen DS.NATIONALITY
gebildet. Die Spalte hat also den Wert von DS.NATIONALITY
. Die obige Tabelle zeigt uns, dass die Datenstrom-Variable 3 Werte annehmen kann. Diese finden sich als Zeilen in der Regel wieder. Je nach aktuellem Wert von DS.NATIONALITY
wird dann die dazu passende Ressource mit der passenden Flagge zurückgegeben. Hat die Datenstrom-Variable beispielsweise den Wert CH , trifft die 2. Spalte auf die Bedingung zu und der Wert der Regel ist ${ch_flag}
, also die Binäre Ressource ch_flag
mit der Schweizer Flagge. Die Regel kann dann in das Dokument eingebunden werden. Im Dokument wird dann die richtige Flagge angezeigt.
Scroll Pagebreak |
---|
Wertfindung innerhalb einer Regel
Gibt es in der Regel mehrere Spalten, die alle Spaltenbedingungen erfüllen, dann ist die oberste Regel in der Liste die zutreffende Regel und ihr Rückgabewert der Wert der Regel. Alle danach kommenden Zeilen werden nicht beachtet. (Das ist auch in Abb. A der Fall, denn Zeile #4 erfüllt ebenfalls alle Spaltenbedingungen, Zeile #3 steht jedoch weiter oben). Nachfolgend ist dargestellt, wie der Wert einer Regel bestimmt wird:
Abbildung B: Durchlauf Wertbestimmung der Regel D
Die Regel in Abb. BD hat 3 Spalten und 3 Zeilen. Jede Spalte definiert eine Bedingung, jede Zeile einen Wert pro Spalte. Die Prüfung beginnt in Zeile 1, Spalte 1. Ist der Wert von Zeile 1 in Spalte 1 identisch zur Spaltenbedingungzum Spaltenwert, wird mit der Prüfung von Spalte 2 in Zeile 1 fortgefahren. Ist der Wert von Zeile 1 in Spalte 2 wieder identisch zur Spaltenbedingung zum Spaltenwert der 2. Spalte, wird mit der Prüfung von Spalte 3 in Zeile 1 fortgefahren. Ist auch der Wert von Spalte 3 in Zeile 1 in Spalte 3 identisch zur Spaltenbedingungidentisch zum Spaltenwert, trifft die gesamte Zeile zu und der Rückgabewert der Zeile ist der Wert der Regel (grüne Pfeile). Hat eine der Spalten in Zeile 1 einen anderen Wert als die zugehörige Spaltenbedingung, trifft also nicht auf die Bedingung zu, wird die Prüfung der Zeile abgebrochen abgebrochen und mit der Prüfung der nächsten Zeile fortgefahren. Dort wird dann wieder in der 1. Spalte begonnen. Wurden alle Zeilen geprüft und keine davon erfüllt alle Spaltenbedingungen, ist der Wert der Regel undefiniert, da kein Rückgabewert ausgewählt werden kann ( rote Pfeile ).
In Abb. A ist der Verlauf folgendermaßen:
Abbildung C: Wertfindung bei Abb. A
Der Wert der Regel ist also TRUE
.
Natürlich machen die Werte der Beispielregel aus Abb. A + C nur begrenzt Sinn, da es keinen semantischen Zusammenhang
zwischen den Bedingungen und den Rückgabewerten gibt und die Rückgabewerte verschiedene Datentypen haben, um zu zeigen,
dass in Regeln alle Datentypen kombiniert werden können. In der Praxis werden Sie Regel erstellen, deren Werte einen Zusammenhang haben.
Um zu verhindern, dass der Wert einer Regel undefiniert (leer) ist, falls keine der Zeilen alle Bedingungen erfüllt, können Sie unter den regulären Zeilen eine weitere Zeile einfügen, die in allen Spalten den Operator * als Wert hat, also immer gültig ist . In dieser Zeile definieren Sie dann als Rückgabewert einen Standard-Wert. Trifft keine der regulären Auswahlmöglichkeiten zu, wird diese Standardzeile ausgewählt und der Wert der Regel ist der Standard-Wert. Dieses Vorgehen wurde in Abb. A durch Zeile #4 verwirklicht.
Boolsche Operatoren
Das R-S definiert einige boolsche Operatoren, mit denen Sie Vergleiche anstellen können. Auch wenn Sie explizit keinen Operator angeben wird ein Operator verwendet, nämlich der Operator EQUAL
: Die Bedingung ist wahr, wenn Wert A = Wert B , also wenn die Spalte in der Zeile den gleichen Wert hat wie die Spalte. Bisher sind wir in Regeln von diesem Verhalten ausgegangen: Der Wert in der Zeile muss identisch zum Wert der entsprechenden Spalte sein. Dies ist aber nur das Standardverhalten, das Sie durch boolsche Operatoren verändern können. In der Praxis werden Sie oft mit Operatoren arbeiten, nämlich immer dann, wenn Werte nicht nur gleich sein sollen, sondern in einer bestimmten Beziehung zueinander stehen sollen. Folgende Operatoren existieren im R-S:
Erweitern | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
| |||||||||||
|
Erweitern | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
| |||||||||||
|
Erweitern | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
| |||||||||||
|
Erweitern | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
| |||||||||||
|
Erweitern | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
| |||||||||||
|
Erweitern | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
| |||||||||||
|
Klicken Sie einen Operatortyp an, um seine Beschreibung zu sehen.
Manipulation durch Funktionen
Natürlich können Sie in Regeln auch Funktionen in EVAL-Anweisungen benutzen. Dies ist oft sinnvoll, um Daten aufzubereiten und zu manipulieren. Nachfolgend werden einige Beispiele gezeigt, wie Sie Funktionen sinnvoll zur Datenmanipulation einsetzen können. Für einen Überblick über alle Funktionen, beachten Sie bitte den Artikel über Funktionen in EVAL-Anweisungen.
Beispiel 1: ToLowerS() / ToUpperS()
STRINGs
werden im R-S case-sensitive behandelt, es wird also zwischen Groß- und Kleinschreibung unterschieden: "HalloWelt" und "hallowelt" sind verschiedene Strings. Wenn Sie eine Datenstrom-Variable oder andere Ressource, die einen String enthält, in einer Regel verwenden, müssen Sie Groß- und Kleinschreibung beachten:
Beispielregel G
Der Rückgabewert der Regel ist aufgrund der Unterscheidung zwischen Groß- und Kleinschreibung 1. Da die exakte Schreibweise des Strings oft nicht bekannt ist, können Sie die Funktionen ToLowerS / ToUpperS benutzen: ToLowerS konvertiert alle Zeichen des Strings in Kleinbuchstaben, ToUpperS alle Zeichen in Großbuchstaben:
Beispielregel H
Der Rückgabewert der Beispielregel H ist jetzt 0. Strings müssen in der Funktion in " " eingeschlossen werden. Sie müssen die Groß-/Kleinschreibung jetzt nicht mehr beachten, sondern nur sicherstellen, dass alle Strings ausschließlich Klein- oder Großbuchstaben enthalten. Externe Strings in Ressourcen müssen Sie deshalb auch durch die Funktion konvertieren lassen:
Beispielregel I
In Beispielregel I sind die Namen der Kunden in Variablen enthalten, die auch konvertiert werden müssen, wenn Sie nicht schon explizit kleingeschrieben sind.
Beispiel 2: IndexS()
Wenn Sie sich nur dafür interessieren, ob ein String einen anderen String enthält, können Sie die Funktion IndexS verwenden. Diese sucht nach einem Substring im String und gibt die Position zurück. Enthält der String den gesuchten String nicht, ist der Rückgabewert -1. Angenommen, im Transaktions-Formular ist die Datenstrom-Variable DS.PAYMENT_TYPE
definiert, mit folgender Syntax:
Codeblock |
---|
BANK_STADT_ZAHLUNGSART_optional:KREDITKARTENANBIETER |
wobei ZAHLUNGSART
: KREDITKARTE sein kann.
Codeblock |
---|
DEUTSCHE BANK_FRANKFURT_KREDITKARTE_VISA |
Wir erstellen eine Regel die lediglich überprüfen soll, ob per Kreditkarte gezahlt wird:
Beispielregel J
IndexS eignet sich hier deshalb, weil man nicht weiß, an welcher Stelle im String das Wort "KREDITKARTE" steht und weil es unmöglich wäre, für jede mögliche Bank, vor allem für jede mögliche Stadt eine eigene Zeile mit dem kompletten String zu definieren.
Beispiel 3: SubtDate()
Mithilfe von SubtDate können Sie eine Anzahl von Tagen von einem Datum abziehen lassen (Analog dazu: AddDate()). Im folgenden Beispiel wird die Funktion dazu verwendet, zu berechnen, wie lange eine Person schon Kunde ist:
Beispielregel K
Mit SubtDate werden vom heutigen Datum DS.DATE
90 Tage abgezogen. Ist das neue Datum größer als der Wert in DS.CUST_SINCE
, ist die Person seit mehr als 90 Tagen Kunde: Zeile #1 trifft zu.
In diesen 3 Beispielen haben Sie gesehen, wie man Funktionen in Regeln verwenden kann. Weitere Funktionen finden Sie im Abschnitt über Funktionen in EVAL-Anweisungen . Nachfolgend einige praxisnähere Beispiele, wie man Regeln sinnvoller nutzen kann: