Working of Oracle Business Rules

Question

Hello,
We are trying to evaluate Oracle Buiness Rules packaged with 10gIAS 10.1.3. We are playing around with how-to-rules-java/vehicleRent demo and created following set of rules. We are not able explain the output of TestMain.java program. Couldn't find any documentation around how internally it evaluates the rules!
Can you pls help us understand the behaviour?
Ruleset: RL
========
1. ruleset vehicleRent
2.
3. {
4.
5. rule UnderAge
6. {
7. priority = 4;
8. if
9. (
10. (
11. fact carrental.Driver v0_Driver && (
12. (v0_Driver.age >= 15)) &&
13. fact carrental.Driver v1_Driver && (
14. (v1_Driver.age > 40)))
15. )
16.
17. {
18. DM.println("Rule 1 - "+v0_Driver.getAge());
19. v1_Driver.age = v1_Driver.getAge()+10;
20. }
21. } //end rule UnderAge;
22.
23. rule MatchAge
24. {
25. priority = 1;
26. if
27. (
28. (
29. fact carrental.Driver v0_Driver && (
30. (v0_Driver.age > 45)))
31. )
32.
33. {
34. DM.println("Rule 2 - "+v0_Driver.getAge());
35. }
36. } //end rule MatchAge;
37.
38. rule AgainMatchAge
39. {
40. priority = 0;
41. if
42. (
43. (
44. fact carrental.Driver v0_Driver && (
45. (v0_Driver.age > 43)))
46. )
47.
48. {
49. DM.println("Rule 3 - "+v0_Driver.getAge());
50. }
51. } //end rule AgainMatchAge;
52.
53. rule RetractRule
54. {
55. priority = 3;
56. if
57. (
58. (
59. fact carrental.Driver v0_Driver && (
60. ((v0_Driver.age <= 44) && (v0_Driver.age > 40))))
61. )
62.
63. {
64. DM.println("Retracting age: "+v0_Driver.age);
65. retract( v0_Driver );
66. ;
67. }
68. } //end rule RetractRule;
69. }// end ruleset vehicleRent
TestMain.java
==========
Date daveLicIssueDate = getDate( "10/1/1969" );
Driver d1 = new Driver( "d111", "Dave", 50, "sports", "full",
daveLicIssueDate, 0, 1, true );
//assert driver qun, will NOT satify the rule
Date qunLicIssueDate = getDate( "8/1/2004" );
Driver d2 = new Driver( "d222", "Qun", 15, "truck", "provisional",
qunLicIssueDate, 0, 0, true );
//assert driver lance
Date lanceLicIssueDate = getDate( "6/1/2004" );
Driver d3 = new Driver( "d333", "Lance", 44, "motorcycle", "full",
lanceLicIssueDate, 0, 1, true );
session.callFunctionWithArgument( "assert", d1 );
session.callFunctionWithArgument( "assert", d2 );
session.callFunctionWithArgument( "assert", d3 );
session.callFunctionWithArgument( "run", rsname );
=====================
OUTPUT:
=======
Rule 1 - 44
Rule 1 - 15
Rule 1 - 64
Rule 1 - 60
Rule 1 - 15
Rule 1 - 70
Retracting age: 74
Rule 2 - 80
Rule 3 - 80

Answer 1

Some documentation text:
Many users are surprised by the results for the following code:
class F {int i; };
rule r1 {
if (fact F F1 && fact F F2) {
println("Results: " + F1.i + ", " + F2.i);
assert(new F(i:1));
assert(new F(i:2));
run();
How many lines will be printed? The answer is 4 lines because fact F1 and
fact F2 can be the same instance and will be compared in each operand. Thus,
the example above results in the following output:
Results: 2, 2
Results: 2, 1
Results: 1, 2
Results: 1, 1
Of course if a third F is constructed (e.g. assert(new F(i:3));) then nine
lines will be printed and if, at the same time, a third term && fact F F3 is
added than 27 lines will be printed.
If the user is attempting to find all combinations and orders of distinct facts, they must add and additional term to the test:
rule r1 {
if (fact F F1 && fact F F2 && F1 != F2) {
println("Results: " + F1.i + ", " + F2.i);
This would then print out:
Results: 2, 1
Results: 1, 2
The simplest (although not the fasted) way to find all combinations of facts, regardless of their order, is to use:
rule r1 {
if (fact F F1 && fact F F2 && id(F1) < id(F2)) {
println("Results: " + F1.i + ", " + F2.i);
Because the function id() takes longer to execute in test pattern than a direct comparison, the fastest method is to test on a unique value in each object. For example, you could add an integer value property “oid” to your class that is assigned a unique value for each instance of the class. The rule using this would look like:
rule r1 {
if (fact F F1 && fact F F2 && F1.oid < F2.oid) {
println("Results: " + F1.i + ", " + F2.i);
This problem may also arise if the user attempt to remove all duplicate facts from the rule engine. They may initially write a function like:
rule rRemoveDups {
if (fact F F1 && fact F F2 && F1.i = F2.i) {
retract(F2);
However, this rule will remove all facts of type F, not just the duplicates because F1 and F2 may be the same fact instance. The correct version of this rule is:
rule rRemoveDups {
if (fact F F1 && fact F F2 && F1 != F2 && F1.i = F2.i) {
retract(F2);
}