Regeln zur Datenvalidierung sinnvoll formulieren

[Caps]

Hallöle,

z.Zt. stehe ich vor einem Problem und sehe vllt. die Lösung vor lauter Bäumen nicht, daher meine Frage:

Mein Server bekommt vom Client eine Schlüssel-Wert-Liste zur Verarbeitung.

Diese Liste soll nun mithilfe folgender Vorgehensweise (syntaktisch und inhaltlich) validiert werden:
- Ein Satz von Regeln wird durchlaufen.
- Wenn ein Wert aus der Liste mithilfe einer der Regeln zu valide ausgewertet wurde, so soll dieses Prüfergebnis in einer Lookup-Table gespeichert werden, damit für diesen Wert nicht später nocheinmal die Validierungsregel abgearbeitet werden braucht.

Nun ist aber die Frage, wie ich die Regeln formuliere, insb. um so wenig wie möglich von der Reihenfolge der Abarbeitung der Regeln abhängig zu sein.


Beispiel:

Eingabeliste
a=Max
b=15

Regelsatz
Regel_1 = "Wenn a=Max, dann muss b kleiner als 20 sein."
Regel_2 = "b muss eine Zahl sein."

Hier passiert nun folgendes:
Wenn ich die Regeln in ihrer Formulierungsreihenfolge abarbeite (Regel_1, Regel_2), dann knallt es, falls b keine Zahl sondern z.B. ein String ist. D.h. ich bin von der Reihenfolge der Abarbeitung der Regeln abhängig. Ich müsste Regel_1 also eigentlich umformulieren in "Wenn a=Max, dann muss b eine Zahl sein und kleiner als 20 sein.". Damit habe ich aber eine Redundanz zu Regel_2. Sinnvoller wäre es nun, Regel_2 vor Regel_1 aufzurufen.
Das Blöde ist, dass ich viele komplizierte Regeln habe und sicher den Überblick verlieren werde.
Wie würdet Ihr das lösen?

Danke für Tipps!
lg Caps


ps Ich bin zur Vermeidung von Redundanz darauf gekommen, die Regeln in Minterme zu packen, eine DNF aufzubauen und dann auszuklammern. Das Problem dabei ist aber, dass, wenn sich eine Regel ändert, ich den ganzen Salat ausmultiplizieren und hinterher wieder ausklammern muss.
Die Regeln werden in einer Programmiersprache wie PHP formuliert werden, daher geht vllt. kein Algo zur Schrumpfung logischer Formeln, keine Ahnung... (?)

[ULIK]

Deine Regel 1 ist doch vom Typ: wenn die Bedingung erfüllt ist, dann prüfe zusätzliche Regel

Also dein Regelstapel würde zuerst einmal nur die Regeln 1 und 2 enthalten. Dann prüfst Du den ersten Datensatz. Wenn nun a = MAX ist, dann fügst Du deiner abzuarbeitenden Regelliste zwei neue zusätzliche Regeln zu: b ist Zahl und b < 20 (wobei das eigentlich nur die Regel b < 20 ist, denn das kleiner impliziert ja schon daß b eine Zahl ist) und gehst weiter zu nächsten Regel.
Für der zweiten Satz der Eingabewerte setzt Du den Regelstapel wieder zurück auf die ursprünglichen Regeln.

In welche Reihenfolge Du dann die Einträge aus deiner Eingabeliste prüfst, ist dann egal, denn es wird immer sichergestellt, daß alle Regeln auf alle Werte angewendet werden.

[hanvas]

Zitat von Caps:

Hallöle,

Hier passiert nun folgendes:
Wenn ich die Regeln in ihrer Formulierungsreihenfolge abarbeite (Regel_1, Regel_2), dann knallt es, falls b keine Zahl sondern z.B. ein String ist. D.h. ich bin von der Reihenfolge der Abarbeitung der Regeln abhängig. Ich müsste Regel_1 also eigentlich umformulieren in "Wenn a=Max, dann muss b eine Zahl sein und kleiner als 20 sein.". Damit habe ich aber eine Redundanz zu Regel_2. Sinnvoller wäre es nun, Regel_2 vor Regel_1 aufzurufen.
Das Blöde ist, dass ich viele komplizierte Regeln habe und sicher den Überblick verlieren werde.
Wie würdet Ihr das lösen?

Was Du suchst ist im Grunde ein Expertensystem bzw. der RETE Algorithmus, dieser wird seit Jahren in allen Arten von Expertensystemen und "Business Rules Engines" eingesetzt.

Wenn Du mit Kanonen auf Spatzen schießen willst, eines der bekanntesten Expertensysteme ist sicher CLIPS[3], welches sich auch in Delphi einbetten lässt. Es gibt auch komerzielle, weitgehend CLips kompatible Komponenten für Delphi die was Du brauchst (und viel mehr) vermutlich abdecken werden und flexibler verwenden lassen.

cu Ha-Jö


[1] https://de.wikipedia.org/wiki/Rete-Algorithmus

[2] http://www.riversoftavg.com/inferenceengine.htm

[3] http://clipsrules.sourceforge.net/

[Caps]

Hi,

danke Euch für die Antworten!

@ULIK:
Das Problem ist aber, soweit ich sehe, dass ich einen String nicht mit "<" prüfen kann, da kriege ich eine Typverletzung, d.h. ich muss schon verifiziert haben, dass die Variable numerisch ist, womit die Reihenfolge der Regeln wieder Wichtigkeit erhält. Oder hab ich was falsch verstanden?

@hanvas:
Ok, danke für die Links. Ich bin noch nicht sicher, ob ich Kanonen will, aber gut zu wissen .


lg
Caps

[ULIK]

Zitat von Caps:

@ULIK:
Das Problem ist aber, soweit ich sehe, dass ich einen String nicht mit "<" prüfen kann, da kriege ich eine Typverletzung, d.h. ich muss schon verifiziert haben, dass die Variable numerisch ist, womit die Reihenfolge der Regeln wieder Wichtigkeit erhält. Oder hab ich was falsch verstanden?

Deine Regel 1 ist doch vom Typ: Wenn Bedingung zutrifft, dann erstelle neue Regel. Dein Regelwerk muß ja als erstes die Bedingung prüfen, ob A=MAX. Wenn diese erfüllt ist, dann ist die Aktion: erstelle zwei neue Regeln: 1. B ist Zahl und 2. b < 20

Deine Regelwerk schaut also so aus:

Original:

• Regel_1 = "Wenn a=Max, dann muss b kleiner als 20 sein."
• Regel_2 = "b muss eine Zahl sein."

Nach Auswertung Regel 1 wenn a=Max zutrifft

• Regel_2 = "b muss eine Zahl sein."
• Regel_3 = "b muss eine Zahl sein."
• Regel_4 = "b < 20"

Du mußt deine Regeln so formulieren, daß sie entweder direkt ausgewertet werden können (wie Regel 2) oder die Auswertung nur wieder zusätzliche Regeln generiert. Ist es nun etwas verständlicher?

[Caps]

Hm, ok, aber in Deinem Beispiel muss ja auch Regel_3 vor Regel_4 ausgewertet werden, d.h. diese Reihenfolge muss mir bei der Formulierung der Regeln schon bekannt sein. Dann kann ich sie auch gleich ausschreiben, statt sie generieren zu lassen(?). Oder liege ich immernoch schief?

lg Caps

[ULIK]

Stimmt, nur '<' impliziert ja immer auch ein 'Wert ist zahl'. Sprich eigentlich ist die Regel 'b < 20' auch nicht 'atomar' sondern müßte 'wenn b Zahl ist, dann Prüfe b < 20' lauten.
Ich denke, daß es darauf hinausläuft zuerst einen Satz an 'atomaren' Regeln zu prüfen und dann erst die davon abgeleiteten. Damit bist Du dann unabhängiger von der Reihenfolge.

[Caps]

Ja, stimmt, atomare Regeln sollten auf jeden Fall zuerst ausgewertet werden.
Ich probiere mal mein Glück...

[himitsu]

oder "implizite" Regeln

"b < 20" = "b ist Zahl und kleiner 20"
bzw. "b" wird mit Zahl verglichen -> wenn b keine Zahl, dann False (nicht valide)

Wenn die Regel einen Fehler erzeugt (ungültige Typumwandlung, Zugriff auf nichtvorhandene Felder, ...), dann ist sie nicht valide.
So ist jede Regel für sich erstmal auswertbar, egal in welcher Reihenfolge die Regeln kommen.
Die Auswerung der Regel darf aber inaktive Zweige nicht auswerten. Also bei Regel_1: (a <> "Max") or (b < 20) und a nicht max, dann darf b nicht ausgewertet werden und keinen Fehler werfen, wenn b keine Zahl ist.

[TigerLilly]

Ich würde meine Regel mit einer Reihenfolge und einer Abhängigkeit versehen (wenn dann).

zB:
1 a=Max
1.1 b ist Zahl
1.2 b > 20
2 a <> Max
2.1
2.2
...

Jetzt müssten wir wissen, wie deine Regeln aufgebaut sind + wie verschachtelt die sein können, ob du damit genug hast.