Chapter 16. DRL (Drools Rule Language) rules DRL (Drools Rule Language) rules are business rules that you define directly in .drl text files. These DRL files are the source in which all other rule assets in Business Central are ultimately rendered. You can create and manage DRL files within the Business Central interface, or create them externally as part of a Maven or Java project using Red Hat CodeReady Studio or another integrated development environment (IDE). A DRL file can contain one or more rules that define at a minimum the rule conditions ( when ) and actions ( then ). The DRL designer in Business Central provides syntax highlighting for Java, DRL, and XML. DRL files consist of the following components: Components in a DRL file The following example DRL rule determines the age limit in a loan application decision service: Example rule for loan application age limit A DRL file can contain single or multiple rules, queries, and functions, and can define resource declarations such as imports, globals, and attributes that are assigned and used by your rules and queries. The DRL package must be listed at the top of a DRL file and the rules are typically listed last. All other DRL components can follow any order. Each rule must have a unique name within the rule package. If you use the same rule name more than once in any DRL file in the package, the rules fail to compile. Always enclose rule names with double quotation marks ( rule "rule name" ) to prevent possible compilation errors, especially if you use spaces in rule names. All data objects related to a DRL rule must be in the same project package as the DRL file in Business Central. Assets in the same package are imported by default. Existing assets in other packages can be imported with the DRL rule. 16.1. Packages in DRL A package is a folder of related assets in Red Hat Process Automation Manager, such as data objects, DRL files, decision tables, and other asset types. A package also serves as a unique namespace for each group of rules. A single rule base can contain multiple packages. You typically store all the rules for a package in the same file as the package declaration so that the package is self-contained. However, you can import objects from other packages that you want to use in the rules. The following example is a package name and namespace for a DRL file in a mortgage application decision service: Example package definition in a DRL file 16.2. Import statements in DRL Similar to import statements in Java, imports in DRL files identify the fully qualified paths and type names for any objects that you want to use in the rules. You specify the package and data object in the format packageName.objectName , with multiple imports on separate lines. The decision engine automatically imports classes from the Java package with the same name as the DRL package and from the package java.lang . The following example is an import statement for a loan application object in a mortgage application decision service: Example import statement in a DRL file 16.3. Functions in DRL Functions in DRL files put semantic code in your rule source file instead of in Java classes. Functions are especially useful if an action ( then ) part of a rule is used repeatedly and only the parameters differ for each rule. Above the rules in the DRL file, you can declare the function or import a static method from a helper class as a function, and then use the function by name in an action ( then ) part of the rule. The following examples illustrate a function that is either declared or imported in a DRL file: Example function declaration with a rule (option 1) Example function import with a rule (option 2) 16.4. Queries in DRL Queries in DRL files search the working memory of the decision engine for facts related to the rules in the DRL file. You add the query definitions in DRL files and then obtain the matching results in your application code. Queries search for a set of defined conditions and do not require when or then specifications. Query names are global to the KIE base and therefore must be unique among all other rule queries in the project. To return the results of a query, you construct a QueryResults definition using ksession.getQueryResults("name") , where "name" is the query name. This returns a list of query results, which enable you to retrieve the objects that matched the query. You define the query and query results parameters above the rules in the DRL file. The following example is a query definition in a DRL file for underage applicants in a mortgage application decision service, with the accompanying application code: Example query definition in a DRL file Example application code to obtain query results QueryResults results = ksession.getQueryResults( "people under the age of 21" ); System.out.println( "we have " + results.size() + " people under the age of 21" ); You can also iterate over the returned QueryResults using a standard for loop. Each element is a QueryResultsRow that you can use to access each of the columns in the tuple. Example application code to obtain and iterate over query results QueryResults results = ksession.getQueryResults( "people under the age of 21" ); System.out.println( "we have " + results.size() + " people under the age of 21" ); System.out.println( "These people are under the age of 21:" ); for ( QueryResultsRow row : results ) { Person person = ( Person ) row.get( "person" ); System.out.println( person.getName() + "\n" ); } 16.5. Type declarations and metadata in DRL Declarations in DRL files define new fact types or metadata for fact types to be used by rules in the DRL file: New fact types: The default fact type in the java.lang package of Red Hat Process Automation Manager is Object , but you can declare other types in DRL files as needed. Declaring fact types in DRL files enables you to define a new fact model directly in the decision engine, without creating models in a lower-level language like Java. You can also declare a new type when a domain model is already built and you want to complement this model with additional entities that are used mainly during the reasoning process. Metadata for fact types: You can associate metadata in the format @key(value) with new or existing facts. Metadata can be any kind of data that is not represented by the fact attributes and is consistent among all instances of that fact type. The metadata can be queried at run time by the decision engine and used in the reasoning process. 16.5.1. Type declarations without metadata in DRL A declaration of a new fact does not require any metadata, but must include a list of attributes or fields. If a type declaration does not include identifying attributes, the decision engine searches for an existing fact class in the classpath and raises an error if the class is missing. The following example is a declaration of a new fact type Person with no metadata in a DRL file: Example declaration of a new fact type with a rule In this example, the new fact type Person has the three attributes name , dateOfBirth , and address . Each attribute has a type that can be any valid Java type, including another class that you create or a fact type that you previously declared. The dateOfBirth attribute has the type java.util.Date , from the Java API, and the address attribute has the previously defined fact type Address . To avoid writing the fully qualified name of a class every time you declare it, you can define the full class name as part of the import clause: Example type declaration with the fully qualified class name in the import When you declare a new fact type, the decision engine generates at compile time a Java class representing the fact type. The generated Java class is a one-to-one JavaBeans mapping of the type definition. For example, the following Java class is generated from the example Person type declaration: Generated Java class for the Person fact type declaration public class Person implements Serializable { private String name; private java.util.Date dateOfBirth; private Address address; // Empty constructor public Person() {...} // Constructor with all fields public Person( String name, Date dateOfBirth, Address address ) {...} // If keys are defined, constructor with keys public Person( ...keys... ) {...} // Getters and setters // `equals` and `hashCode` // `toString` } You can then use the generated class in your rules like any other fact, as illustrated in the rule example with the Person type declaration: Example rule that uses the declared Person fact type 16.5.2. Enumerative type declarations in DRL DRL supports the declaration of enumerative types in the format declare enum <factType> , followed by a comma-separated list of values ending with a semicolon. You can then use the enumerative list in the rules in the DRL file. For example, the following enumerative type declaration defines days of the week for an employee scheduling rule: Example enumerative type declaration with a scheduling rule 16.5.3. Extended type declarations in DRL DRL supports type declaration inheritance in the format declare <factType1> extends <factType2> . To extend a type declared in Java by a subtype declared in DRL, you repeat the parent type in a declaration statement without any fields. For example, the following type declarations extend a Student type from a top-level Person type, and a LongTermStudent type from the Student subtype: Example extended type declarations 16.5.4. Type declarations with metadata in DRL You can associate metadata in the format @key(value) (the value is optional) with fact types or fact attributes. Metadata can be any kind of data that is not represented by the fact attributes and is consistent among all instances of that fact type. The metadata can be queried at run time by the decision engine and used in the reasoning process. Any metadata that you declare before the attributes of a fact type are assigned to the fact type, while metadata that you declare after an attribute are assigned to that particular attribute. In the following example, the two metadata attributes @author and @dateOfCreation are declared for the Person fact type, and the two metadata items @key and @maxLength are declared for the name attribute. The @key metadata attribute has no required value, so the parentheses and the value are omitted. Example metadata declaration for fact types and attributes For declarations of metadata attributes for existing types, you can identify the fully qualified class name as part of the import clause for all declarations or as part of the individual declare clause: Example metadata declaration for an imported type Example metadata declaration for a declared type 16.5.5. Metadata tags for fact type and attribute declarations in DRL Although you can define custom metadata attributes in DRL declarations, the decision engine also supports the following predefined metadata tags for declarations of fact types or fact type attributes. Note The examples in this section that refer to the VoiceCall class assume that the sample application domain model includes the following class details: VoiceCall fact class in an example Telecom domain model public class VoiceCall { private String originNumber; private String destinationNumber; private Date callDateTime; private long callDuration; // in milliseconds // Constructors, getters, and setters } @role This tag determines whether a given fact type is handled as a regular fact or an event in the decision engine during complex event processing. Default parameter: fact Supported parameters: fact , event Example: Declare VoiceCall as event type @timestamp This tag is automatically assigned to every event in the decision engine. By default, the time is provided by the session clock and assigned to the event when it is inserted into the working memory of the decision engine. You can specify a custom time stamp attribute instead of the default time stamp added by the session clock. Default parameter: The time added by the decision engine session clock Supported parameters: Session clock time or custom time stamp attribute Example: Declare VoiceCall timestamp attribute @duration This tag determines the duration time for events in the decision engine. Events can be interval-based events or point-in-time events. Interval-based events have a duration time and persist in the working memory of the decision engine until their duration time has lapsed. Point-in-time events have no duration and are essentially interval-based events with a duration of zero. By default, every event in the decision engine has a duration of zero. You can specify a custom duration attribute instead of the default. Default parameter: Null (zero) Supported parameters: Custom duration attribute Example: Declare VoiceCall duration attribute @expires This tag determines the time duration before an event expires in the working memory of the decision engine. By default, an event expires when the event can no longer match and activate any of the current rules. You can define an amount of time after which an event should expire. This tag definition also overrides the implicit expiration offset calculated from temporal constraints and sliding windows in the KIE base. This tag is available only when the decision engine is running in stream mode. Default parameter: Null (event expires after event can no longer match and activate rules) Supported parameters: Custom timeOffset attribute in the format [ #d][#h][#m][#s][ [ms]] Example: Declare expiration offset for VoiceCall events @typesafe This tab determines whether a given fact type is compiled with or without type safety. By default, all type declarations are compiled with type safety enabled. You can override this behavior to type-unsafe evaluation, where all constraints are generated as MVEL constraints and executed dynamically. This is useful when dealing with collections that do not have any generics or mixed type collections. Default parameter: true Supported parameters: true , false Example: Declare VoiceCall for type-unsafe evaluation @serialVersionUID This tag defines an identifying serialVersionUID value for a serializable class in a fact declaration. If a serializable class does not explicitly declare a serialVersionUID , the serialization run time calculates a default serialVersionUID value for that class based on various aspects of the class, as described in the Java Object Serialization Specification . However, for optimal deserialization results and for greater compatibility with serialized KIE sessions, set the serialVersionUID as needed in the relevant class or in your DRL declarations. Default parameter: Null Supported parameters: Custom serialVersionUID integer Example: Declare serialVersionUID for a VoiceCall class @key This tag enables a fact type attribute to be used as a key identifier for the fact type. The generated class can then implement the equals() and hashCode() methods to determine if two instances of the type are equal to each other. The decision engine can also generate a constructor using all the key attributes as parameters. Default parameter: None Supported parameters: None Example: Declare Person type attributes as keys For this example, the decision engine checks the firstName and lastName attributes to determine if two instances of Person are equal to each other, but it does not check the age attribute. The decision engine also implicitly generates three constructors: one without parameters, one with the @key fields, and one with all fields: Example constructors from the key declarations You can then create instances of the type based on the key constructors, as shown in the following example: Example instance using the key constructor Person person = new Person( "John", "Doe" ); @position This tag determines the position of a declared fact type attribute or field in a positional argument, overriding the default declared order of attributes. You can use this tag to modify positional constraints in patterns while maintaining a consistent format in your type declarations and positional arguments. You can use this tag only for fields in classes on the classpath. If some fields in a single class use this tag and some do not, the attributes without this tag are positioned last, in the declared order. Inheritance of classes is supported, but not interfaces of methods. Default parameter: None Supported parameters: Any integer Example: Declare a fact type and override declared order In this example, the attributes are prioritized in positional arguments in the following order: lastName firstName age occupation In positional arguments, you do not need to specify the field name because the position maps to a known named field. For example, the argument Person( lastName == "Doe" ) is the same as Person( "Doe"; ) , where the lastName field has the highest position annotation in the DRL declaration. The semicolon ; indicates that everything before it is a positional argument. You can mix positional and named arguments on a pattern by using the semicolon to separate them. Any variables in a positional argument that have not yet been bound are bound to the field that maps to that position. The following example patterns illustrate different ways of constructing positional and named arguments. The patterns have two constraints and a binding, and the semicolon differentiates the positional section from the named argument section. Variables and literals and expressions using only literals are supported in positional arguments, but not variables alone. Example patterns with positional and named arguments Positional arguments can be classified as input arguments or output arguments . Input arguments contain a previously declared binding and constrain against that binding using unification. Output arguments generate the declaration and bind it to the field represented by the positional argument when the binding does not yet exist. In extended type declarations, use caution when defining @position annotations because the attribute positions are inherited in subtypes. This inheritance can result in a mixed attribute order that can be confusing in some cases. Two fields can have the same @position value and consecutive values do not need to be declared. If a position is repeated, the conflict is solved using inheritance, where position values in the parent type have precedence, and then using the declaration order from the first to last declaration. For example, the following extended type declarations result in mixed positional priorities: Example extended fact type with mixed position annotations In this example, the attributes are prioritized in positional arguments in the following order: lastName (position 0 in the parent type) school (position 0 in the subtype) firstName (position 1 in the parent type) degree (position 1 in the subtype) age (position 2 in the parent type) occupation (first field with no position annotation) graduationDate (second field with no position annotation) 16.5.6. Property-change settings and listeners for fact types By default, the decision engine does not re-evaluate all fact patterns for fact types each time a rule is triggered, but instead reacts only to modified properties that are constrained or bound inside a given pattern. For example, if a rule calls modify() as part of the rule actions but the action does not generate new data in the KIE base, the decision engine does not automatically re-evaluate all fact patterns because no data was modified. This property reactivity behavior prevents unwanted recursions in the KIE base and results in more efficient rule evaluation. This behavior also means that you do not always need to use the no-loop rule attribute to avoid infinite recursion. You can modify or disable this property reactivity behavior with the following KnowledgeBuilderConfiguration options, and then use a property-change setting in your Java class or DRL files to fine-tune property reactivity as needed: ALWAYS : (Default) All types are property reactive, but you can disable property reactivity for a specific type by using the @classReactive property-change setting. ALLOWED : No types are property reactive, but you can enable property reactivity for a specific type by using the @propertyReactive property-change setting. DISABLED : No types are property reactive. All property-change listeners are ignored. Example property reactivity setting in KnowledgeBuilderConfiguration Alternatively, you can update the drools.propertySpecific system property in the standalone.xml file of your Red Hat Process Automation Manager distribution: Example property reactivity setting in system properties <system-properties> ... <property name="drools.propertySpecific" value="ALLOWED"/> ... </system-properties> The decision engine supports the following property-change settings and listeners for fact classes or declared DRL fact types: @classReactive If property reactivity is set to ALWAYS in the decision engine (all types are property reactive), this tag disables the default property reactivity behavior for a specific Java class or a declared DRL fact type. You can use this tag if you want the decision engine to re-evaluate all fact patterns for the specified fact type each time the rule is triggered, instead of reacting only to modified properties that are constrained or bound inside a given pattern. Example: Disable default property reactivity in a DRL type declaration Example: Disable default property reactivity in a Java class @classReactive public static class Person { private String firstName; private String lastName; } @propertyReactive If property reactivity is set to ALLOWED in the decision engine (no types are property reactive unless specified), this tag enables property reactivity for a specific Java class or a declared DRL fact type. You can use this tag if you want the decision engine to react only to modified properties that are constrained or bound inside a given pattern for the specified fact type, instead of re-evaluating all fact patterns for the fact each time the rule is triggered. Example: Enable property reactivity in a DRL type declaration (when reactivity is disabled globally) Example: Enable property reactivity in a Java class (when reactivity is disabled globally) @propertyReactive public static class Person { private String firstName; private String lastName; } @watch This tag enables property reactivity for additional properties that you specify in-line in fact patterns in DRL rules. This tag is supported only if property reactivity is set to ALWAYS in the decision engine, or if property reactivity is set to ALLOWED and the relevant fact type uses the @propertyReactive tag. You can use this tag in DRL rules to add or exclude specific properties in fact property reactivity logic. Default parameter: None Supported parameters: Property name, * (all), ! (not), !* (no properties) Example: Enable or disable property reactivity in fact patterns The decision engine generates a compilation error if you use the @watch tag for properties in a fact type that uses the @classReactive tag (disables property reactivity) or when property reactivity is set to ALLOWED in the decision engine and the relevant fact type does not use the @propertyReactive tag. Compilation errors also arise if you duplicate properties in listener annotations, such as @watch( firstName, ! firstName ) . @propertyChangeSupport For facts that implement support for property changes as defined in the JavaBeans Specification , this tag enables the decision engine to monitor changes in the fact properties. Example: Declare property change support in JavaBeans object 16.5.7. Access to DRL declared types in application code Declared types in DRL are typically used within the DRL files while Java models are typically used when the model is shared between rules and applications. Because declared types are generated at KIE base compile time, an application cannot access them until application run time. In some cases, an application needs to access and handle facts directly from the declared types, especially when the application wraps the decision engine and provides higher-level, domain-specific user interfaces for rules management. To handle declared types directly from the application code, you can use the org.drools.definition.type.FactType API in Red Hat Process Automation Manager. Through this API, you can instantiate, read, and write fields in the declared fact types. The following example code modifies a Person fact type directly from an application: Example application code to handle a declared fact type through the FactType API import java.util.Date; import org.kie.api.definition.type.FactType; import org.kie.api.KieBase; import org.kie.api.runtime.KieSession; ... // Get a reference to a KIE base with the declared type: KieBase kbase = ... // Get the declared fact type: FactType personType = kbase.getFactType("org.drools.examples", "Person"); // Create instances: Object bob = personType.newInstance(); // Set attribute values: personType.set(bob, "name", "Bob" ); personType.set(bob, "dateOfBirth", new Date()); personType.set(bob, "address", new Address("King's Road","London","404")); // Insert the fact into a KIE session: KieSession ksession = ... ksession.insert(bob); ksession.fireAllRules(); // Read attributes: String name = (String) personType.get(bob, "name"); Date date = (Date) personType.get(bob, "dateOfBirth"); The API also includes other helpful methods, such as setting all the attributes at once, reading values from a Map collection, or reading all attributes at once into a Map collection. Although the API behavior is similar to Java reflection, the API does not use reflection and relies on more performant accessors that are implemented with generated bytecode. 16.6. Global variables in DRL Global variables in DRL files typically provide data or services for the rules, such as application services used in rule consequences, and return data from rules, such as logs or values added in rule consequences. You set the global value in the working memory of the decision engine through a KIE session configuration or REST operation, declare the global variable above the rules in the DRL file, and then use it in an action ( then ) part of the rule. For multiple global variables, use separate lines in the DRL file. The following example illustrates a global variable list configuration for the decision engine and the corresponding global variable definition in the DRL file: Example global list configuration for the decision engine Example global variable definition with a rule Warning Do not use global variables to establish conditions in rules unless a global variable has a constant immutable value. Global variables are not inserted into the working memory of the decision engine, so the decision engine cannot track value changes of variables. Do not use global variables to share data between rules. Rules always reason and react to the working memory state, so if you want to pass data from rule to rule, assert the data as facts into the working memory of the decision engine. A use case for a global variable might be an instance of an email service. In your integration code that is calling the decision engine, you obtain your emailService object and then set it in the working memory of the decision engine. In the DRL file, you declare that you have a global of type emailService and give it the name "email" , and then in your rule consequences, you can use actions such as email.sendSMS(number, message) . If you declare global variables with the same identifier in multiple packages, then you must set all the packages with the same type so that they all reference the same global value. 16.7. Rule attributes in DRL Rule attributes are additional specifications that you can add to business rules to modify rule behavior. In DRL files, you typically define rule attributes above the rule conditions and actions, with multiple attributes on separate lines, in the following format: The following table lists the names and supported values of the attributes that you can assign to rules: Table 16.1. Rule attributes Attribute Value salience An integer defining the priority of the rule. Rules with a higher salience value are given higher priority when ordered in the activation queue. Example: salience 10 enabled A Boolean value. When the option is selected, the rule is enabled. When the option is not selected, the rule is disabled. Example: enabled true date-effective A string containing a date and time definition. The rule can be activated only if the current date and time is after a date-effective attribute. Example: date-effective "4-Sep-2018" date-expires A string containing a date and time definition. The rule cannot be activated if the current date and time is after the date-expires attribute. Example: date-expires "4-Oct-2018" no-loop A Boolean value. When the option is selected, the rule cannot be reactivated (looped) if a consequence of the rule re-triggers a previously met condition. When the condition is not selected, the rule can be looped in these circumstances. Example: no-loop true agenda-group A string identifying an agenda group to which you want to assign the rule. Agenda groups allow you to partition the agenda to provide more execution control over groups of rules. Only rules in an agenda group that has acquired a focus are able to be activated. Example: agenda-group "GroupName" activation-group A string identifying an activation (or XOR) group to which you want to assign the rule. In activation groups, only one rule can be activated. The first rule to fire will cancel all pending activations of all rules in the activation group. Example: activation-group "GroupName" duration A long integer value defining the duration of time in milliseconds after which the rule can be activated, if the rule conditions are still met. Example: duration 10000 timer A string identifying either int (interval) or cron timer definitions for scheduling the rule. Example: timer ( cron:* 0/15 * * * ? ) (every 15 minutes) calendar A Quartz calendar definition for scheduling the rule. Example: calendars "* * 0-7,18-23 ? * *" (exclude non-business hours) auto-focus A Boolean value, applicable only to rules within agenda groups. When the option is selected, the time the rule is activated, a focus is automatically given to the agenda group to which the rule is assigned. Example: auto-focus true lock-on-active A Boolean value, applicable only to rules within rule flow groups or agenda groups. When the option is selected, the time the ruleflow group for the rule becomes active or the agenda group for the rule receives a focus, the rule cannot be activated again until the ruleflow group is no longer active or the agenda group loses the focus. This is a stronger version of the no-loop attribute, because the activation of a matching rule is discarded regardless of the origin of the update (not only by the rule itself). This attribute is ideal for calculation rules where you have a number of rules that modify a fact and you do not want any rule re-matching and firing again. Example: lock-on-active true ruleflow-group A string identifying a rule flow group. In rule flow groups, rules can fire only when the group is activated by the associated rule flow. Example: ruleflow-group "GroupName" dialect A string identifying either JAVA or MVEL as the language to be used for code expressions in the rule. By default, the rule uses the dialect specified at the package level. Any dialect specified here overrides the package dialect setting for the rule. Example: dialect "JAVA" Note When you use Red Hat Process Automation Manager without the executable model, the dialect "JAVA" rule consequences support only Java 5 syntax. For more information about executable models, see Packaging and deploying an Red Hat Process Automation Manager project . 16.7.1. Timer and calendar rule attributes in DRL Timers and calendars are DRL rule attributes that enable you to apply scheduling and timing constraints to your DRL rules. These attributes require additional configurations depending on the use case. The timer attribute in DRL rules is a string identifying either int (interval) or cron timer definitions for scheduling a rule and supports the following formats: Timer attribute formats Example interval timer attributes Example cron timer attribute Interval timers follow the semantics of java.util.Timer objects, with an initial delay and an optional repeat interval. Cron timers follow standard Unix cron expressions. The following example DRL rule uses a cron timer to send an SMS text message every 15 minutes: Example DRL rule with a cron timer Generally, a rule that is controlled by a timer becomes active when the rule is triggered and the rule consequence is executed repeatedly, according to the timer settings. The execution stops when the rule condition no longer matches incoming facts. However, the way the decision engine handles rules with timers depends on whether the decision engine is in active mode or in passive mode . By default, the decision engine runs in passive mode and evaluates rules, according to the defined timer settings, when a user or an application explicitly calls fireAllRules() . Conversely, if a user or application calls fireUntilHalt() , the decision engine starts in active mode and evaluates rules continually until the user or application explicitly calls halt() . When the decision engine is in active mode, rule consequences are executed even after control returns from a call to fireUntilHalt() and the decision engine remains reactive to any changes made to the working memory. For example, removing a fact that was involved in triggering the timer rule execution causes the repeated execution to terminate, and inserting a fact so that some rule matches causes that rule to be executed. However, the decision engine is not continually active , but is active only after a rule is executed. Therefore, the decision engine does not react to asynchronous fact insertions until the execution of a timer-controlled rule. Disposing a KIE session terminates all timer activity. When the decision engine is in passive mode, rule consequences of timed rules are evaluated only when fireAllRules() is invoked again. However, you can change the default timer-execution behavior in passive mode by configuring the KIE session with a TimedRuleExecutionOption option, as shown in the following example: KIE session configuration to automatically execute timed rules in passive mode KieSessionConfiguration ksconf = KieServices.Factory.get().newKieSessionConfiguration(); ksconf.setOption( TimedRuleExecutionOption.YES ); KSession ksession = kbase.newKieSession(ksconf, null); You can additionally set a FILTERED specification on the TimedRuleExecutionOption option that enables you to define a callback to filter those rules, as shown in the following example: KIE session configuration to filter which timed rules are automatically executed KieSessionConfiguration ksconf = KieServices.Factory.get().newKieSessionConfiguration(); conf.setOption( new TimedRuleExecutionOption.FILTERED(new TimedRuleExecutionFilter() { public boolean accept(Rule[] rules) { return rules[0].getName().equals("MyRule"); } }) ); For interval timers, you can also use an expression timer with expr instead of int to define both the delay and interval as an expression instead of a fixed value. The following example DRL file declares a fact type with a delay and period that are then used in the subsequent rule with an expression timer: Example rule with an expression timer The expressions, such as USDd and USDp in this example, can use any variable defined in the pattern-matching part of the rule. The variable can be any String value that can be parsed into a time duration or any numeric value that is internally converted in a long value for a duration in milliseconds. Both interval and expression timers can use the following optional parameters: start and end : A Date or a String representing a Date or a long value. The value can also be a Number that is transformed into a Java Date in the format new Date( ((Number) n).longValue() ) . repeat-limit : An integer that defines the maximum number of repetitions allowed by the timer. If both the end and the repeat-limit parameters are set, the timer stops when the first of the two is reached. Example timer attribute with optional start , end , and repeat-limit parameters timer (int: 30s 1h; start=3-JAN-2020, end=4-JAN-2020, repeat-limit=50) In this example, the rule is scheduled for every hour, after a delay of 30 seconds each hour, beginning on 3 January 2020 and ending either on 4 January 2020 or when the cycle repeats 50 times. If the system is paused (for example, the session is serialized and then later deserialized), the rule is scheduled only one time to recover from missing activations regardless of how many activations were missed during the pause, and then the rule is subsequently scheduled again to continue in sync with the timer setting. The calendar attribute in DRL rules is a Quartz calendar definition for scheduling a rule and supports the following format: Calendar attribute format Example calendar attributes You can adapt a Quartz calendar based on the Quartz calendar API and then register the calendar in the KIE session, as shown in the following example: Adapting a Quartz Calendar Calendar weekDayCal = QuartzHelper.quartzCalendarAdapter(org.quartz.Calendar quartzCal) Registering the calendar in the KIE session ksession.getCalendars().set( "weekday", weekDayCal ); You can use calendars with standard rules and with rules that use timers. The calendar attribute can contain one or more comma-separated calendar names written as String literals. The following example rules use both calendars and timers to schedule the rules: Example rules with calendars and timers 16.8. Rule conditions in DRL (WHEN) The when part of a DRL rule (also known as the Left Hand Side (LHS) of the rule) contains the conditions that must be met to execute an action. Conditions consist of a series of stated patterns and constraints , with optional bindings and supported rule condition elements (keywords), based on the available data objects in the package. For example, if a bank requires loan applicants to have over 21 years of age, then the when condition of an "Underage" rule would be Applicant( age < 21 ) . Note DRL uses when instead of if because if is typically part of a procedural execution flow during which a condition is checked at a specific point in time. In contrast, when indicates that the condition evaluation is not limited to a specific evaluation sequence or point in time, but instead occurs continually at any time. Whenever the condition is met, the actions are executed. If the when section is empty, then the conditions are considered to be true and the actions in the then section are executed the first time a fireAllRules() call is made in the decision engine. This is useful if you want to use rules to set up the decision engine state. The following example rule uses empty conditions to insert a fact every time the rule is executed: Example rule without conditions If rule conditions use multiple patterns with no defined keyword conjunctions (such as and , or , or not ), the default conjunction is and : Example rule without keyword conjunctions 16.8.1. Patterns and constraints A pattern in a DRL rule condition is the segment to be matched by the decision engine. A pattern can potentially match each fact that is inserted into the working memory of the decision engine. A pattern can also contain constraints to further define the facts to be matched. In the simplest form, with no constraints, a pattern matches a fact of the given type. In the following example, the type is Person , so the pattern will match against all Person objects in the working memory of the decision engine: Example pattern for a single fact type The type does not need to be the actual class of some fact object. Patterns can refer to superclasses or even interfaces, potentially matching facts from many different classes. For example, the following pattern matches all objects in the working memory of the decision engine: Example pattern for all objects The parentheses of a pattern enclose the constraints, such as the following constraint on the person's age: Example pattern with a constraint A constraint is an expression that returns true or false . Pattern constraints in DRL are essentially Java expressions with some enhancements, such as property access, and some differences, such as equals() and !equals() semantics for == and != (instead of the usual same and not same semantics). Any JavaBeans property can be accessed directly from pattern constraints. A bean property is exposed internally using a standard JavaBeans getter that takes no arguments and returns something. For example, the age property is written as age in DRL instead of the getter getAge() : DRL constraint syntax with JavaBeans properties Red Hat Process Automation Manager uses the standard JDK Introspector class to achieve this mapping, so it follows the standard JavaBeans specification. For optimal decision engine performance, use the property access format, such as age , instead of using getters explicitly, such as getAge() . Warning Do not use property accessors to change the state of the object in a way that might affect the rules because the decision engine caches the results of the match between invocations for higher efficiency. For example, do not use property accessors in the following ways: public int getAge() { age++; // Do not do this. return age; } public int getAge() { Date now = DateUtil.now(); // Do not do this. return DateUtil.differenceInYears(now, birthday); } Instead of following the second example, insert a fact that wraps the current date in the working memory and update that fact between fireAllRules() as needed. However, if the getter of a property cannot be found, the compiler uses the property name as a fallback method name, without arguments: Fallback method if object is not found You can also nest access properties in patterns, as shown in the following example. Nested properties are indexed by the decision engine. Example pattern with nested property access Warning In stateful KIE sessions, use nested accessors carefully because the working memory of the decision engine is not aware of any of the nested values and does not detect when they change. Either consider the nested values immutable while any of their parent references are inserted into the working memory, or, if you want to modify a nested value, mark all of the outer facts as updated. In the example, when the houseNumber property changes, any Person with that Address must be marked as updated. You can use any Java expression that returns a boolean value as a constraint inside the parentheses of a pattern. Java expressions can be mixed with other expression enhancements, such as property access: Example pattern with a constraint using property access and Java expression You can change the evaluation priority by using parentheses, as in any logical or mathematical expression: Example evaluation order of constraints You can also reuse Java methods in constraints, as shown in the following example: Example constraints with reused Java methods Warning Do not use constraints to change the state of the object in a way that might affect the rules because the decision engine caches the results of the match between invocations for higher efficiency. Any method that is executed on a fact in the rule conditions must be a read-only method. Also, the state of a fact should not change between rule invocations unless those facts are marked as updated in the working memory on every change. For example, do not use a pattern constraint in the following ways: Standard Java operator precedence applies to constraint operators in DRL, and DRL operators follow standard Java semantics except for the == and != operators. The == operator uses null-safe equals() semantics instead of the usual same semantics. For example, the pattern Person( firstName == "John" ) is similar to java.util.Objects.equals(person.getFirstName(), "John") , and because "John" is not null, the pattern is also similar to "John".equals(person.getFirstName()) . The != operator uses null-safe !equals() semantics instead of the usual not same semantics. For example, the pattern Person( firstName != "John" ) is similar to !java.util.Objects.equals(person.getFirstName(), "John") . If the field and the value of a constraint are of different types, the decision engine uses type coercion to resolve the conflict and reduce compilation errors. For instance, if "ten" is provided as a string in a numeric evaluator, a compilation error occurs, whereas "10" is coerced to a numeric 10. In coercion, the field type always takes precedence over the value type: Example constraint with a value that is coerced For groups of constraints, you can use a delimiting comma , to use implicit and connective semantics: Example patterns with multiple constraints Note Although the && and , operators have the same semantics, they are resolved with different priorities. The && operator precedes the || operator, and both the && and || operators together precede the , operator. Use the comma operator at the top-level constraint for optimal decision engine performance and human readability. You cannot embed a comma operator in a composite constraint expression, such as in parentheses: Example of misused comma in composite constraint expression 16.8.2. Bound variables in patterns and constraints You can bind variables to patterns and constraints to refer to matched objects in other portions of a rule. Bound variables can help you define rules more efficiently or more consistently with how you annotate facts in your data model. To differentiate more easily between variables and fields in a rule, use the standard format USDvariable for variables, especially in complex rules. This convention is helpful but not required in DRL. For example, the following DRL rule uses the variable USDp for a pattern with the Person fact: Pattern with a bound variable Similarly, you can also bind variables to properties in pattern constraints, as shown in the following example: Note Constraint binding considers only the first atomic expression that follows it. In the following example the pattern only binds the age of the person to the variable USDa : For clearer and more efficient rule definitions, separate constraint bindings and constraint expressions. Although mixed bindings and expressions are supported, which can complicate patterns and affect evaluation efficiency. In the preceding example, if you want to bind to the variable USDa the double of the person's age, you must make it an atomic expression by wrapping it in parentheses as shown in the following example: The decision engine does not support bindings to the same declaration, but does support unification of arguments across several properties. While positional arguments are always processed with unification, the unification symbol := exists for named arguments. The following example patterns unify the age property across two Person facts: Example pattern with unification Unification declares a binding for the first occurrence and constrains to the same value of the bound field for sequence occurrences. 16.8.3. Nested constraints and inline casts In some cases, you might need to access multiple properties of a nested object, as shown in the following example: Example pattern to access multiple properties You can group these property accessors to nested objects with the syntax .( <constraints> ) for more readable rules, as shown in the following example: Example pattern with grouped constraints Note The period prefix . differentiates the nested object constraints from a method call. When you work with nested objects in patterns, you can use the syntax <type>#<subtype> to cast to a subtype and make the getters from the parent type available to the subtype. You can use either the object name or fully qualified class name, and you can cast to one or multiple subtypes, as shown in the following examples: Example patterns with inline casting to a subtype These example patterns cast Address to LongAddress , and additionally to DetailedCountry in the last example, making the parent getters available to the subtypes in each case. You can use the instanceof operator to infer the results of the specified type in subsequent uses of that field with the pattern, as shown in the following example: If an inline cast is not possible (for example, if instanceof returns false ), the evaluation is considered false . 16.8.4. Date literal in constraints By default, the decision engine supports the date format dd-mmm-yyyy . You can customize the date format, including a time format mask if needed, by providing an alternative format mask with the system property drools.dateformat="dd-mmm-yyyy hh:mm" . You can also customize the date format by changing the language locale with the drools.defaultlanguage and drools.defaultcountry system properties (for example, the locale of Thailand is set as drools.defaultlanguage=th and drools.defaultcountry=TH ). Example pattern with a date literal restriction 16.8.5. Supported operators in DRL pattern constraints DRL supports standard Java semantics for operators in pattern constraints, with some exceptions and with some additional operators that are unique in DRL. The following list summarizes the operators that are handled differently in DRL constraints than in standard Java semantics or that are unique in DRL constraints. .() , # Use the .() operator to group property accessors to nested objects, and use the # operator to cast to a subtype in nested objects. Casting to a subtype makes the getters from the parent type available to the subtype. You can use either the object name or fully qualified class name, and you can cast to one or multiple subtypes. Example patterns with nested objects Note The period prefix . differentiates the nested object constraints from a method call. Example patterns with inline casting to a subtype !. Use this operator to dereference a property in a null-safe way. The value to the left of the !. operator must be not null (interpreted as != null ) in order to give a positive result for pattern matching. Example constraint with null-safe dereferencing [] Use this operator to access a List value by index or a Map value by key. Example constraints with List and Map access < , <= , > , >= Use these operators on properties with natural ordering. For example, for Date fields, the < operator means before , and for String fields, the operator means alphabetically before . These properties apply only to comparable properties. Example constraints with before operator == , != Use these operators as equals() and !equals() methods in constraints, instead of the usual same and not same semantics. Example constraint with null-safe equality Example constraint with null-safe not equality && , || Use these operators to create an abbreviated combined relation condition that adds more than one restriction on a field. You can group constraints with parentheses () to create a recursive syntax pattern. Example constraints with abbreviated combined relation matches , not matches Use these operators to indicate that a field matches or does not match a specified Java regular expression. Typically, the regular expression is a String literal, but variables that resolve to a valid regular expression are also supported. These operators apply only to String properties. If you use matches against a null value, the resulting evaluation is always false . If you use not matches against a null value, the resulting evaluation is always true . As in Java, regular expressions that you write as String literals must use a double backslash \\ to escape. Example constraint to match or not match a regular expression contains , not contains Use these operators to verify whether a field that is an Array or a Collection contains or does not contain a specified value. These operators apply to Array or Collection properties, but you can also use these operators in place of String.contains() and !String.contains() constraints checks. Example constraints with contains and not contains for a Collection Example constraints with contains and not contains for a String literal Note For backward compatibility, the excludes operator is a supported synonym for not contains . memberOf , not memberOf Use these operators to verify whether a field is a member of or is not a member of an Array or a Collection that is defined as a variable. The Array or Collection must be a variable. Example constraints with memberOf and not memberOf with a Collection soundslike Use this operator to verify whether a word has almost the same sound, using English pronunciation, as the given value (similar to the matches operator). This operator uses the Soundex algorithm. Example constraint with soundslike str Use this operator to verify whether a field that is a String starts with or ends with a specified value. You can also use this operator to verify the length of the String . Example constraints with str in , notin Use these operators to specify more than one possible value to match in a constraint (compound value restriction). This functionality of compound value restriction is supported only in the in and not in operators. The second operand of these operators must be a comma-separated list of values enclosed in parentheses. You can provide values as variables, literals, return values, or qualified identifiers. These operators are internally rewritten as a list of multiple restrictions using the operators == or != . Example constraints with in and notin 16.8.6. Operator precedence in DRL pattern constraints DRL supports standard Java operator precedence for applicable constraint operators, with some exceptions and with some additional operators that are unique in DRL. The following table lists DRL operator precedence where applicable, from highest to lowest precedence: Table 16.2. Operator precedence in DRL pattern constraints Operator type Operators Notes Nested or null-safe property access . , .() , !. Not standard Java semantics List or Map access [] Not standard Java semantics Constraint binding : Not standard Java semantics Multiplicative * , /% Additive + , - Shift >> , >>> , << Relational < , <= , > , >= , instanceof Equality == != Uses equals() and !equals() semantics, not standard Java same and not same semantics Non-short-circuiting AND & Non-short-circuiting exclusive OR ^ Non-short-circuiting inclusive OR | Logical AND && Logical OR || Ternary ? : Comma-separated AND , Not standard Java semantics 16.8.7. Supported rule condition elements in DRL (keywords) DRL supports the following rule condition elements (keywords) that you can use with the patterns that you define in DRL rule conditions: and Use this to group conditional components into a logical conjunction. Infix and prefix and are supported. You can group patterns explicitly with parentheses () . By default, all listed patterns are combined with and when no conjunction is specified. Example patterns with and Note Do not use a leading declaration binding with the and keyword (as you can with or , for example). A declaration can only reference a single fact at a time, and if you use a declaration binding with and , then when and is satisfied, it matches both facts and results in an error. Example misuse of and or Use this to group conditional components into a logical disjunction. Infix and prefix or are supported. You can group patterns explicitly with parentheses () . You can also use pattern binding with or , but each pattern must be bound separately. Example patterns with or Example patterns with or and pattern binding The decision engine does not directly interpret the or element but uses logical transformations to rewrite a rule with or as a number of sub-rules. This process ultimately results in a rule that has a single or as the root node and one sub-rule for each of its condition elements. Each sub-rule is activated and executed like any normal rule, with no special behavior or interaction between the sub-rules. Therefore, consider the or condition element a shortcut for generating two or more similar rules that, in turn, can create multiple activations when two or more terms of the disjunction are true. exists Use this to specify facts and constraints that must exist. This option is triggered on only the first match, not subsequent matches. If you use this element with multiple patterns, enclose the patterns with parentheses () . Example patterns with exists not Use this to specify facts and constraints that must not exist. If you use this element with multiple patterns, enclose the patterns with parentheses () . Example patterns with not forall Use this to verify whether all facts that match the first pattern match all the remaining patterns. When a forall construct is satisfied, the rule evaluates to true . This element is a scope delimiter, so it can use any previously bound variable, but no variable bound inside of it is available for use outside of it. Example rule with forall In this example, the rule selects all Employee objects whose type is "fulltime" . For each fact that matches this pattern, the rule evaluates the patterns that follow (badge color) and if they match, the rule evaluates to true . To state that all facts of a given type in the working memory of the decision engine must match a set of constraints, you can use forall with a single pattern for simplicity. Example rule with forall and a single pattern You can use forall constructs with multiple patterns or nest them with other condition elements, such as inside a not element construct. Example rule with forall and multiple patterns Example rule with forall and not Note The format forall( p1 p2 p3 ... ) is equivalent to not( p1 and not( and p2 p3 ... ) ) . from Use this to specify a data source for a pattern. This enables the decision engine to reason over data that is not in the working memory. The data source can be a sub-field on a bound variable or the result of a method call. The expression used to define the object source is any expression that follows regular MVEL syntax. Therefore, the from element enables you to easily use object property navigation, execute method calls, and access maps and collection elements. Example rule with from and pattern binding Example rule with from and a graph notation Example rule with from to iterate over all objects Note For large collections of objects, instead of adding an object with a large graph that the decision engine must iterate over frequently, add the collection directly to the KIE session and then join the collection in the condition, as shown in the following example: Example rule with from and lock-on-active rule attribute Important Using from with lock-on-active rule attribute can result in rules not being executed. You can address this issue in one of the following ways: Avoid using the from element when you can insert all facts into the working memory of the decision engine or use nested object references in your constraint expressions. Place the variable used in the modify() block as the last sentence in your rule condition. Avoid using the lock-on-active rule attribute when you can explicitly manage how rules within the same ruleflow group place activations on one another. The pattern that contains a from clause cannot be followed by another pattern starting with a parenthesis. The reason for this restriction is that the DRL parser reads the from expression as "from USDl (String() or Number())" and it cannot differentiate this expression from a function call. The simplest workaround to this is to wrap the from clause in parentheses, as shown in the following example: Example rules with from used incorrectly and correctly entry-point Use this to define an entry point, or event stream , corresponding to a data source for the pattern. This element is typically used with the from condition element. You can declare an entry point for events so that the decision engine uses data from only that entry point to evaluate the rules. You can declare an entry point either implicitly by referencing it in DRL rules or explicitly in your Java application. Example rule with from entry-point Example Java application code with EntryPoint object and inserted facts import org.kie.api.runtime.KieSession; import org.kie.api.runtime.rule.EntryPoint; // Create your KIE base and KIE session as usual: KieSession session = ... // Create a reference to the entry point: EntryPoint atmStream = session.getEntryPoint("ATM Stream"); // Start inserting your facts into the entry point: atmStream.insert(aWithdrawRequest); collect Use this to define a collection of objects that the rule can use as part of the condition. The rule obtains the collection either from a specified source or from the working memory of the decision engine. The result pattern of the collect element can be any concrete class that implements the java.util.Collection interface and provides a default no-arg public constructor. You can use Java collections like List , LinkedList , and HashSet , or your own class. If variables are bound before the collect element in a condition, you can use the variables to constrain both your source and result patterns. However, any binding made inside the collect element is not available for use outside of it. Example rule with collect In this example, the rule assesses all pending alarms in the working memory of the decision engine for each given system and groups them in a List . If three or more alarms are found for a given system, the rule is executed. You can also use the collect element with nested from elements, as shown in the following example: Example rule with collect and nested from accumulate Use this to iterate over a collection of objects, execute custom actions for each of the elements, and return one or more result objects (if the constraints evaluate to true ). This element is a more flexible and powerful form of the collect condition element. You can use predefined functions in your accumulate conditions or implement custom functions as needed. You can also use the abbreviation acc for accumulate in rule conditions. Use the following format to define accumulate conditions in rules: Preferred format for accumulate Note Although the decision engine supports alternate formats for the accumulate element for backward compatibility, this format is preferred for optimal performance in rules and applications. The decision engine supports the following predefined accumulate functions. These functions accept any expression as input. average min max count sum collectList collectSet In the following example rule, min , max , and average are accumulate functions that calculate the minimum, maximum, and average temperature values over all the readings for each sensor: Example rule with accumulate to calculate temperature values The following example rule uses the average function with accumulate to calculate the average profit for all items in an order: Example rule with accumulate to calculate average profit To use custom, domain-specific functions in accumulate conditions, create a Java class that implements the org.kie.api.runtime.rule.AccumulateFunction interface. For example, the following Java class defines a custom implementation of an AverageData function: Example Java class with custom implementation of average function // An implementation of an accumulator capable of calculating average values public class AverageAccumulateFunction implements org.kie.api.runtime.rule.AccumulateFunction<AverageAccumulateFunction.AverageData> { public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { } public void writeExternal(ObjectOutput out) throws IOException { } public static class AverageData implements Externalizable { public int count = 0; public double total = 0; public AverageData() {} public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { count = in.readInt(); total = in.readDouble(); } public void writeExternal(ObjectOutput out) throws IOException { out.writeInt(count); out.writeDouble(total); } } /* (non-Javadoc) * @see org.kie.api.runtime.rule.AccumulateFunction#createContext() */ public AverageData createContext() { return new AverageData(); } /* (non-Javadoc) * @see org.kie.api.runtime.rule.AccumulateFunction#init(java.io.Serializable) */ public void init(AverageData context) { context.count = 0; context.total = 0; } /* (non-Javadoc) * @see org.kie.api.runtime.rule.AccumulateFunction#accumulate(java.io.Serializable, java.lang.Object) */ public void accumulate(AverageData context, Object value) { context.count++; context.total += ((Number) value).doubleValue(); } /* (non-Javadoc) * @see org.kie.api.runtime.rule.AccumulateFunction#reverse(java.io.Serializable, java.lang.Object) */ public void reverse(AverageData context, Object value) { context.count--; context.total -= ((Number) value).doubleValue(); } /* (non-Javadoc) * @see org.kie.api.runtime.rule.AccumulateFunction#getResult(java.io.Serializable) */ public Object getResult(AverageData context) { return new Double( context.count == 0 ? 0 : context.total / context.count ); } /* (non-Javadoc) * @see org.kie.api.runtime.rule.AccumulateFunction#supportsReverse() */ public boolean supportsReverse() { return true; } /* (non-Javadoc) * @see org.kie.api.runtime.rule.AccumulateFunction#getResultType() */ public Class< ? > getResultType() { return Number.class; } } To use the custom function in a DRL rule, import the function using the import accumulate statement: Format to import a custom function Example rule with the imported average function 16.8.8. OOPath syntax with graphs of objects in DRL rule conditions OOPath is an object-oriented syntax extension of XPath that is designed for browsing graphs of objects in DRL rule condition constraints. OOPath uses the compact notation from XPath for navigating through related elements while handling collections and filtering constraints, and is specifically useful for graphs of objects. When the field of a fact is a collection, you can use the from condition element (keyword) to bind and reason over all the items in that collection one by one. If you need to browse a graph of objects in the rule condition constraints, the extensive use of the from condition element results in a verbose and repetitive syntax, as shown in the following example: Example rule that browses a graph of objects with from In this example, the domain model contains a Student object with a Plan of study. The Plan can have zero or more Exam instances and an Exam can have zero or more Grade instances. Only the root object of the graph, the Student in this case, needs to be in the working memory of the decision engine for this rule setup to function. As a more efficient alternative to using extensive from statements, you can use the abbreviated OOPath syntax, as shown in the following example: Example rule that browses a graph of objects with OOPath syntax Formally, the core grammar of an OOPath expression is defined in extended Backus-Naur form (EBNF) notation in the following way: EBNF notation for OOPath expressions In practice, an OOPath expression has the following features and capabilities: Starts with a forward slash / or with a question mark and forward slash ?/ if it is a non-reactive OOPath expression (described later in this section). Can dereference a single property of an object with the period . operator. Can dereference multiple properties of an object with the forward slash / operator. If a collection is returned, the expression iterates over the values in the collection. Can filter out traversed objects that do not satisfy one or more constraints. The constraints are written as predicate expressions between square brackets, as shown in the following example: Constraints as a predicate expression Can downcast a traversed object to a subclass of the class declared in the generic collection. Subsequent constraints can also safely access the properties declared only in that subclass, as shown in the following example. Objects that are not instances of the class specified in this inline cast are automatically filtered out. Constraints with downcast objects Can backreference an object of the graph that was traversed before the currently iterated graph. For example, the following OOPath expression matches only the grades that are above the average for the passed exam: Constraints with backreferenced object Can recursively be another OOPath expression, as shown in the following example: Recursive constraint expression Can access objects by their index between square brackets [] , as shown in the following example. To adhere to Java convention, OOPath indexes are 0-based, while XPath indexes are 1-based. Constraints with access to objects by index OOPath expressions can be reactive or non-reactive. The decision engine does not react to updates involving a deeply nested object that is traversed during the evaluation of an OOPath expression. To make these objects reactive to changes, modify the objects to extend the class org.drools.core.phreak.ReactiveObject . After you modify an object to extend the ReactiveObject class, the domain object invokes the inherited method notifyModification to notify the decision engine when one of the fields has been updated, as shown in the following example: Example object method to notify the decision engine that an exam has been moved to a different course public void setCourse(String course) { this.course = course; notifyModification(this); } With the following corresponding OOPath expression, when an exam is moved to a different course, the rule is re-executed and the list of grades matching the rule is recomputed: Example OOPath expression from "Big Data" rule You can also use the ?/ separator instead of the / separator to disable reactivity in only one sub-portion of an OOPath expression, as shown in the following example: Example OOPath expression that is partially non-reactive With this example, the decision engine reacts to a change made to an exam or if an exam is added to the plan, but not if a new grade is added to an existing exam. If an OOPath portion is non-reactive, all remaining portions of the OOPath expression also become non-reactive. For example, the following OOPath expression is completely non-reactive: Example OOPath expression that is completely non-reactive For this reason, you cannot use the ?/ separator more than once in the same OOPath expression. For example, the following expression causes a compilation error: Example OOPath expression with duplicate non-reactivity markers Another alternative for enabling OOPath expression reactivity is to use the dedicated implementations for List and Set interfaces in Red Hat Process Automation Manager. These implementations are the ReactiveList and ReactiveSet classes. A ReactiveCollection class is also available. The implementations also provide reactive support for performing mutable operations through the Iterator and ListIterator classes. The following example class uses these classes to configure OOPath expression reactivity: Example Java class to configure OOPath expression reactivity public class School extends AbstractReactiveObject { private String name; private final List<Child> children = new ReactiveList<Child>(); 1 public void setName(String name) { this.name = name; notifyModification(); 2 } public void addChild(Child child) { children.add(child); 3 // No need to call `notifyModification()` here } } 1 Uses the ReactiveList instance for reactive support over the standard Java List instance. 2 Uses the required notifyModification() method for when a field is changed in reactive support. 3 The children field is a ReactiveList instance, so the notifyModification() method call is not required. The notification is handled automatically, like all other mutating operations performed over the children field. 16.9. Rule actions in DRL (THEN) The then part of the rule (also known as the Right Hand Side (RHS) of the rule) contains the actions to be performed when the conditional part of the rule has been met. Actions consist of one or more methods that execute consequences based on the rule conditions and on available data objects in the package. For example, if a bank requires loan applicants to be over 21 years of age (with a rule condition Applicant( age < 21 ) ) and a loan applicant is under 21 years old, the then action of an "Underage" rule would be setApproved( false ) , declining the loan because the applicant is under age. The main purpose of rule actions is to insert, delete, or modify data in the working memory of the decision engine. Effective rule actions are small, declarative, and readable. If you need to use imperative or conditional code in rule actions, then divide the rule into multiple smaller and more declarative rules. Example rule for loan application age limit 16.9.1. Supported rule action methods in DRL DRL supports the following rule action methods that you can use in DRL rule actions. You can use these methods to modify the working memory of the decision engine without having to first reference a working memory instance. These methods act as shortcuts to the methods provided by the RuleContext class in your Red Hat Process Automation Manager distribution. For all rule action methods, download the Red Hat Process Automation Manager 7.13.5 Source Distribution ZIP file from the Red Hat Customer Portal and navigate to ~/rhpam-7.13.5-sources/src/kie-api-parent-USDVERSION/kie-api/src/main/java/org/kie/api/runtime/rule/RuleContext.java . set Use this to set the value of a field. Example rule action to set the values of a loan application approval modify Use this to specify fields to be modified for a fact and to notify the decision engine of the change. This method provides a structured approach to fact updates. It combines the update operation with setter calls to change object fields. Example rule action to modify a loan application amount and approval update Use this to specify fields and the entire related fact to be updated and to notify the decision engine of the change. After a fact has changed, you must call update before changing another fact that might be affected by the updated values. To avoid this added step, use the modify method instead. Example rule action to update a loan application amount and approval Note If you provide property-change listeners, you do not need to call this method when an object changes. For more information about property-change listeners, see Decision engine in Red Hat Process Automation Manager . insert Use this to insert a new fact into the working memory of the decision engine and to define resulting fields and values as needed for the fact. Example rule action to insert a new loan applicant object insertLogical Use this to insert a new fact logically into the decision engine. The decision engine is responsible for logical decisions on insertions and retractions of facts. After regular or stated insertions, facts must be retracted explicitly. After logical insertions, the facts that were inserted are automatically retracted when the conditions in the rules that inserted the facts are no longer true. Example rule action to logically insert a new loan applicant object delete Use this to remove an object from the decision engine. The keyword retract is also supported in DRL and executes the same action, but delete is typically preferred in DRL code for consistency with the keyword insert . Example rule action to delete a loan applicant object 16.9.2. Other rule action methods from drools variable In addition to the standard rule action methods, the decision engine supports methods in conjunction with the predefined drools variable that you can also use in rule actions. You can use the drools variable to call methods from the org.kie.api.runtime.rule.RuleContext class in your Red Hat Process Automation Manager distribution, which is also the class that the standard rule action methods are based on. For all drools rule action options, download the Red Hat Process Automation Manager 7.13.5 Source Distribution ZIP file from the Red Hat Customer Portal and navigate to ~/rhpam-7.13.5-sources/src/kie-api-parent-USDVERSION/kie-api/src/main/java/org/kie/api/runtime/rule/RuleContext.java . The drools variable contains methods that provide information about the firing rule and the set of facts that activated the firing rule: drools.getRule().getName() : Returns the name of the currently firing rule. drools.getMatch() : Returns the Match that activated the currently firing rule. It contains information that is useful for logging and debugging purposes, for instance drools.getMatch().getObjects() returns the list of objects, enabling rule to fire in the proper tuple order. From the drools variable, you can also obtain a reference to the KieRuntime providing useful methods to interact with the running session, for example: drools.getKieRuntime().halt() : Terminates rule execution if a user or application previously called fireUntilHalt() . When a user or application calls fireUntilHalt() method, the decision engine starts in active mode and evaluates rules until the user or application explicitly calls halt() method. Otherwise, by default, the decision engine runs in passive mode and evaluates rules only when a user or an application explicitly calls fireAllRules() method. drools.getKieRuntime().getAgenda() : Returns a reference to the KIE session Agenda , and in turn provides access to rule activation groups, rule agenda groups, and ruleflow groups. Example call to access agenda group "CleanUp" and set the focus drools.getKieRuntime().getAgenda().getAgendaGroup( "CleanUp" ).setFocus(); + This example sets the focus to a specified agenda group to which the rule belongs. drools.getKieRuntime().setGlobal() , ~.getGlobal() , ~.getGlobals() : Sets or retrieves global variables. drools.getKieRuntime().getEnvironment() : Returns the runtime Environment , similar to your operating system environment. drools.getKieRuntime().getQueryResults(<string> query) : Runs a query and returns the results. 16.9.3. Advanced rule actions with conditional and named consequences In general, effective rule actions are small, declarative, and readable. However, in some cases, the limitation of having a single consequence for each rule can be challenging and lead to verbose and repetitive rule syntax, as shown in the following example rules: Example rules with verbose and repetitive syntax A partial solution to the repetition is to make the second rule extend the first rule, as shown in the following modified example: Partially enhanced example rules with an extended condition As a more efficient alternative, you can consolidate the two rules into a single rule with modified conditions and labelled corresponding rule actions, as shown in the following consolidated example: Consolidated example rule with conditional and named consequences This example rule uses two actions: the usual default action and another action named giveDiscount . The giveDiscount action is activated in the condition with the keyword do when a customer older than 60 years old is found in the KIE base, regardless of whether or not the customer owns a car. You can configure the activation of a named consequence with an additional condition, such as the if statement in the following example. The condition in the if statement is always evaluated on the pattern that immediately precedes it. Consolidated example rule with an additional condition You can also evaluate different rule conditions using a nested if and else if construct, as shown in the following more complex example: Consolidated example rule with more complex conditions This example rule gives a 10% discount and free parking to Golden customers over 60, but only a 5% discount without free parking to Silver customers. The rule activates the consequence named giveDiscount5 with the keyword break instead of do . The keyword do schedules a consequence in the decision engine agenda, enabling the remaining part of the rule conditions to continue being evaluated, while break blocks any further condition evaluation. If a named consequence does not correspond to any condition with do but is activated with break , the rule fails to compile because the conditional part of the rule is never reached. 16.10. Comments in DRL files DRL supports single-line comments prefixed with a double forward slash // and multi-line comments enclosed with a forward slash and asterisk /* ... */ . You can use DRL comments to annotate rules or any related components in DRL files. DRL comments are ignored by the decision engine when the DRL file is processed. Example rule with comments Important The hash symbol # is not supported for DRL comments. 16.11. Error messages for DRL troubleshooting Red Hat Process Automation Manager provides standardized messages for DRL errors to help you troubleshoot and resolve problems in your DRL files. The error messages use the following format: Figure 16.1. Error message format for DRL file problems 1st Block: Error code 2nd Block: Line and column in the DRL source where the error occurred 3rd Block: Description of the problem 4th Block: Component in the DRL source (rule, function, query) where the error occurred 5th Block: Pattern in the DRL source where the error occurred (if applicable) Red Hat Process Automation Manager supports the following standardized error messages: 101: no viable alternative Indicates that the parser reached a decision point but could not identify an alternative. Example rule with incorrect spelling Error message Example rule without a rule name Error message In this example, the parser encountered the keyword when but expected the rule name, so it flags when as the incorrect expected token. Example rule with incorrect syntax Error message Note A line and column value of 0:-1 means the parser reached the end of the source file ( <eof> ) but encountered incomplete constructs, usually due to missing quotation marks "... " , apostrophes '... ' , or parentheses (... ) . 102: mismatched input Indicates that the parser expected a particular symbol that is missing at the current input position. Example rule with an incomplete rule statement Error message Note A line and column value of 0:-1 means the parser reached the end of the source file ( <eof> ) but encountered incomplete constructs, usually due to missing quotation marks "... " , apostrophes '... ' , or parentheses (... ) . Example rule with incorrect syntax Error messages In this example, the syntactic problem results in multiple error messages related to each other. The single solution of replacing the commas , with && operators resolves all errors. If you encounter multiple errors, resolve one at a time in case errors are consequences of errors. 103: failed predicate Indicates that a validating semantic predicate evaluated to false . These semantic predicates are typically used to identify component keywords in DRL files, such as declare , rule , exists , not , and others. Example rule with an invalid keyword Error message The Some text line is invalid because it does not begin with or is not a part of a DRL keyword construct, so the parser fails to validate the rest of the DRL file. Note This error is similar to 102: mismatched input , but usually involves DRL keywords. 104: trailing semi-colon not allowed Indicates that an eval() clause in a rule condition uses a semicolon ; but must not use one. Example rule with eval() and trailing semicolon Error message 105: did not match anything Indicates that the parser reached a sub-rule in the grammar that must match an alternative at least once, but the sub-rule did not match anything. The parser has entered a branch with no way out. Example rule with invalid text in an empty condition Error message In this example, the condition is intended to be empty but the word None is used. This error is resolved by removing None , which is not a valid DRL keyword, data type, or pattern construct. Note If you encounter other DRL error messages that you cannot resolve, contact your Red Hat Technical Account Manager.

Commands:
package import function // Optional query // Optional declare // Optional global // Optional rule "rule name" // Attributes when // Conditions then // Actions end rule "rule2 name"
rule "Underage" salience 15 agenda-group "applicationGroup" when USDapplication : LoanApplication() Applicant( age < 21 ) then USDapplication.setApproved( false ); USDapplication.setExplanation( "Underage" ); end
package org.mortgages;
import org.mortgages.LoanApplication;
function String hello(String applicantName) { return "Hello " + applicantName + "!"; } rule "Using a function" when // Empty then System.out.println( hello( "James" ) ); end
import function my.package.applicant.hello; rule "Using a function" when // Empty then System.out.println( hello( "James" ) ); end
query "people under the age of 21" USDperson : Person( age < 21 ) end
QueryResults results = ksession.getQueryResults( "people under the age of 21" ); System.out.println( "we have " + results.size() + " people under the age of 21" );
QueryResults results = ksession.getQueryResults( "people under the age of 21" ); System.out.println( "we have " + results.size() + " people under the age of 21" ); System.out.println( "These people are under the age of 21:" ); for ( QueryResultsRow row : results ) { Person person = ( Person ) row.get( "person" ); System.out.println( person.getName() + "\n" ); }
declare Person name : String dateOfBirth : java.util.Date address : Address end rule "Using a declared type" when USDp : Person( name == "James" ) then // Insert Mark, who is a customer of James. Person mark = new Person(); mark.setName( "Mark" ); insert( mark ); end
import java.util.Date declare Person name : String dateOfBirth : Date address : Address end
public class Person implements Serializable { private String name; private java.util.Date dateOfBirth; private Address address; // Empty constructor public Person() {...} // Constructor with all fields public Person( String name, Date dateOfBirth, Address address ) {...} // If keys are defined, constructor with keys public Person( ...keys... ) {...} // Getters and setters // `equals` and `hashCode` // `toString` }
rule "Using a declared type" when USDp : Person( name == "James" ) then // Insert Mark, who is a customer of James. Person mark = new Person(); mark.setName( "Mark" ); insert( mark ); end
declare enum DaysOfWeek SUN("Sunday"),MON("Monday"),TUE("Tuesday"),WED("Wednesday"),THU("Thursday"),FRI("Friday"),SAT("Saturday"); fullName : String end rule "Using a declared Enum" when USDemp : Employee( dayOff == DaysOfWeek.MONDAY ) then end
import org.people.Person declare Person end declare Student extends Person school : String end declare LongTermStudent extends Student years : int course : String end
import java.util.Date declare Person @author( Bob ) @dateOfCreation( 01-Feb-2009 ) name : String @key @maxLength( 30 ) dateOfBirth : Date address : Address end
import org.drools.examples.Person declare Person @author( Bob ) @dateOfCreation( 01-Feb-2009 ) end
declare org.drools.examples.Person @author( Bob ) @dateOfCreation( 01-Feb-2009 ) end
public class VoiceCall { private String originNumber; private String destinationNumber; private Date callDateTime; private long callDuration; // in milliseconds // Constructors, getters, and setters }
@role( fact | event )
declare VoiceCall @role( event ) end
@timestamp( <attributeName> )
declare VoiceCall @role( event ) @timestamp( callDateTime ) end
@duration( <attributeName> )
declare VoiceCall @role( event ) @timestamp( callDateTime ) @duration( callDuration ) end
@expires( <timeOffset> )
declare VoiceCall @role( event ) @timestamp( callDateTime ) @duration( callDuration ) @expires( 1h35m ) end
@typesafe( <boolean> )
declare VoiceCall @role( fact ) @typesafe( false ) end
@serialVersionUID( <integer> )
declare VoiceCall @serialVersionUID( 42 ) end
<attributeDefinition> @key
declare Person firstName : String @key lastName : String @key age : int end
Person() // Empty constructor Person( String firstName, String lastName ) Person( String firstName, String lastName, int age )
Person person = new Person( "John", "Doe" );
<attributeDefinition> @position ( <integer> )
declare Person firstName : String @position( 1 ) lastName : String @position( 0 ) age : int @position( 2 ) occupation: String end
Person( "Doe", "John", USDa; ) Person( "Doe", "John"; USDa : age ) Person( "Doe"; firstName == "John", USDa : age ) Person( lastName == "Doe"; firstName == "John", USDa : age )
declare Person firstName : String @position( 1 ) lastName : String @position( 0 ) age : int @position( 2 ) occupation: String end declare Student extends Person degree : String @position( 1 ) school : String @position( 0 ) graduationDate : Date end
KnowledgeBuilderConfiguration config = KnowledgeBuilderFactory.newKnowledgeBuilderConfiguration(); config.setOption(PropertySpecificOption.ALLOWED); KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder(config);
<system-properties> <property name="drools.propertySpecific" value="ALLOWED"/> </system-properties>
declare Person @classReactive firstName : String lastName : String end
@classReactive public static class Person { private String firstName; private String lastName; }
declare Person @propertyReactive firstName : String lastName : String end
@propertyReactive public static class Person { private String firstName; private String lastName; }
<factPattern> @watch ( <property> )
// Listens for changes in both `firstName` (inferred) and `lastName`: Person(firstName == USDexpectedFirstName) @watch( lastName ) // Listens for changes in all properties of the `Person` fact: Person(firstName == USDexpectedFirstName) @watch( * ) // Listens for changes in `lastName` and explicitly excludes changes in `firstName`: Person(firstName == USDexpectedFirstName) @watch( lastName, !firstName ) // Listens for changes in all properties of the `Person` fact except `age`: Person(firstName == USDexpectedFirstName) @watch( *, !age ) // Excludes changes in all properties of the `Person` fact (equivalent to using `@classReactivity` tag): Person(firstName == USDexpectedFirstName) @watch( !* )
declare Person @propertyChangeSupport end
import java.util.Date; import org.kie.api.definition.type.FactType; import org.kie.api.KieBase; import org.kie.api.runtime.KieSession; // Get a reference to a KIE base with the declared type: KieBase kbase = // Get the declared fact type: FactType personType = kbase.getFactType("org.drools.examples", "Person"); // Create instances: Object bob = personType.newInstance(); // Set attribute values: personType.set(bob, "name", "Bob" ); personType.set(bob, "dateOfBirth", new Date()); personType.set(bob, "address", new Address("King's Road","London","404")); // Insert the fact into a KIE session: KieSession ksession = ksession.insert(bob); ksession.fireAllRules(); // Read attributes: String name = (String) personType.get(bob, "name"); Date date = (Date) personType.get(bob, "dateOfBirth");
List<String> list = new ArrayList<>(); KieSession kieSession = kiebase.newKieSession(); kieSession.setGlobal( "myGlobalList", list );
global java.util.List myGlobalList; rule "Using a global" when // Empty then myGlobalList.add( "My global list" ); end
rule "rule_name" // Attribute // Attribute when // Conditions then // Actions end
timer ( int: <initial delay> <repeat interval> ) timer ( cron: <cron expression> )
// Run after a 30-second delay timer ( int: 30s ) // Run every 5 minutes after a 30-second delay each time timer ( int: 30s 5m )
// Run every 15 minutes timer ( cron:* 0/15 * * * ? )
rule "Send SMS message every 15 minutes" timer ( cron:* 0/15 * * * ? ) when USDa : Alarm( on == true ) then channels[ "sms" ].insert( new Sms( USDa.mobileNumber, "The alarm is still on." ); end
KieSessionConfiguration ksconf = KieServices.Factory.get().newKieSessionConfiguration(); ksconf.setOption( TimedRuleExecutionOption.YES ); KSession ksession = kbase.newKieSession(ksconf, null);
KieSessionConfiguration ksconf = KieServices.Factory.get().newKieSessionConfiguration(); conf.setOption( new TimedRuleExecutionOption.FILTERED(new TimedRuleExecutionFilter() { public boolean accept(Rule[] rules) { return rules[0].getName().equals("MyRule"); } }) );
declare Bean delay : String = "30s" period : long = 60000 end rule "Expression timer" timer ( expr: USDd, USDp ) when Bean( USDd : delay, USDp : period ) then // Actions end
timer (int: 30s 1h; start=3-JAN-2020, end=4-JAN-2020, repeat-limit=50)
calendars "<definition or registered name>"
// Exclude non-business hours calendars "* * 0-7,18-23 ? * *" // Weekdays only, as registered in the KIE session calendars "weekday"
Calendar weekDayCal = QuartzHelper.quartzCalendarAdapter(org.quartz.Calendar quartzCal)
ksession.getCalendars().set( "weekday", weekDayCal );
rule "Weekdays are high priority" calendars "weekday" timer ( int:0 1h ) when Alarm() then send( "priority high - we have an alarm" ); end rule "Weekends are low priority" calendars "weekend" timer ( int:0 4h ) when Alarm() then send( "priority low - we have an alarm" ); end
rule "Always insert applicant" when // Empty then // Actions to be executed once insert( new Applicant() ); end // The rule is internally rewritten in the following way: rule "Always insert applicant" when eval( true ) then insert( new Applicant() ); end
rule "Underage" when application : LoanApplication() Applicant( age < 21 ) then // Actions end // The rule is internally rewritten in the following way: rule "Underage" when application : LoanApplication() and Applicant( age < 21 ) then // Actions end
Person()
Object() // Matches all objects in the working memory
Person( age == 50 )
Person( age == 50 ) // This is the same as the following getter format: Person( getAge() == 50 )
public int getAge() { age++; // Do not do this. return age; }
public int getAge() { Date now = DateUtil.now(); // Do not do this. return DateUtil.differenceInYears(now, birthday); }
Person( age == 50 ) // If `Person.getAge()` does not exist, the compiler uses the following syntax: Person( age() == 50 )
Person( address.houseNumber == 50 ) // This is the same as the following format: Person( getAddress().getHouseNumber() == 50 )
Person( age == 50 )
Person( age > 100 && ( age % 10 == 0 ) )
Person( Math.round( weight / ( height * height ) ) < 25.0 )
Person( incrementAndGetAge() == 10 ) // Do not do this.
Person( System.currentTimeMillis() % 1000 == 0 ) // Do not do this.
Person( age == "10" ) // "10" is coerced to 10
// Person is at least 50 years old and weighs at least 80 kilograms: Person( age > 50, weight > 80 ) // Person is at least 50 years old, weighs at least 80 kilograms, and is taller than 2 meters: Person( age > 50, weight > 80, height > 2 )
// Do not use the following format: Person( ( age > 50, weight > 80 ) || height > 2 ) // Use the following format instead: Person( ( age > 50 && weight > 80 ) || height > 2 )
rule "simple rule" when USDp : Person() then System.out.println( "Person " + USDp ); end
// Two persons of the same age: Person( USDfirstAge : age ) // Binding Person( age == USDfirstAge ) // Constraint expression
Person( USDa : age * 2 < 100 )
// Do not use the following format: Person( USDa : age * 2 < 100 ) // Use the following format instead: Person( age * 2 < 100, USDa : age )
Person( USDa : (age * 2) )
Person( USDage := age ) Person( USDage := age )
Person( name == "mark", address.city == "london", address.country == "uk" )
Person( name == "mark", address.( city == "london", country == "uk") )
// Inline casting with subtype name: Person( name == "mark", address#LongAddress.country == "uk" ) // Inline casting with fully qualified class name: Person( name == "mark", address#org.domain.LongAddress.country == "uk" ) // Multiple inline casts: Person( name == "mark", address#LongAddress.country#DetailedCountry.population > 10000000 )
Person( name == "mark", address instanceof LongAddress, address.country == "uk" )
Person( bornBefore < "27-Oct-2009" )
// Ungrouped property accessors: Person( name == "mark", address.city == "london", address.country == "uk" ) // Grouped property accessors: Person( name == "mark", address.( city == "london", country == "uk") )
// Inline casting with subtype name: Person( name == "mark", address#LongAddress.country == "uk" ) // Inline casting with fully qualified class name: Person( name == "mark", address#org.domain.LongAddress.country == "uk" ) // Multiple inline casts: Person( name == "mark", address#LongAddress.country#DetailedCountry.population > 10000000 )
Person( USDstreetName : address!.street ) // This is internally rewritten in the following way: Person( address != null, USDstreetName : address.street )
// The following format is the same as `childList(0).getAge() == 18`: Person(childList[0].age == 18) // The following format is the same as `credentialMap.get("jdoe").isValid()`: Person(credentialMap["jdoe"].valid)
Person( birthDate < USDotherBirthDate ) Person( firstName < USDotherFirstName )
Person( firstName == "John" ) // This is similar to the following formats: java.util.Objects.equals(person.getFirstName(), "John") "John".equals(person.getFirstName())
Person( firstName != "John" ) // This is similar to the following format: !java.util.Objects.equals(person.getFirstName(), "John")
// Simple abbreviated combined relation condition using a single `&&`: Person(age > 30 && < 40) // Complex abbreviated combined relation using groupings: Person(age ((> 30 && < 40) || (> 20 && < 25))) // Mixing abbreviated combined relation with constraint connectives: Person(age > 30 && < 40 || location == "london")
Person( country matches "(USA)?\\S*UK" ) Person( country not matches "(USA)?\\S*UK" )
// Collection with a specified field: FamilyTree( countries contains "UK" ) FamilyTree( countries not contains "UK" ) // Collection with a variable: FamilyTree( countries contains USDvar ) FamilyTree( countries not contains USDvar )
// Sting literal with a specified field: Person( fullName contains "Jr" ) Person( fullName not contains "Jr" ) // String literal with a variable: Person( fullName contains USDvar ) Person( fullName not contains USDvar )
FamilyTree( person memberOf USDeuropeanDescendants ) FamilyTree( person not memberOf USDeuropeanDescendants )
// Match firstName "Jon" or "John": Person( firstName soundslike "John" )
// Verify what the String starts with: Message( routingValue str[startsWith] "R1" ) // Verify what the String ends with: Message( routingValue str[endsWith] "R2" ) // Verify the length of the String: Message( routingValue str[length] 17 )
Person( USDcolor : favoriteColor ) Color( type in ( "red", "blue", USDcolor ) ) Person( USDcolor : favoriteColor ) Color( type notin ( "red", "blue", USDcolor ) )
//Infix `and`: Color( colorType : type ) and Person( favoriteColor == colorType ) //Infix `and` with grouping: (Color( colorType : type ) and (Person( favoriteColor == colorType ) or Person( favoriteColor == colorType )) // Prefix `and`: (and Color( colorType : type ) Person( favoriteColor == colorType )) // Default implicit `and`: Color( colorType : type ) Person( favoriteColor == colorType )
// Causes compile error: USDperson : (Person( name == "Romeo" ) and Person( name == "Juliet"))
//Infix `or`: Color( colorType : type ) or Person( favoriteColor == colorType ) //Infix `or` with grouping: (Color( colorType : type ) or (Person( favoriteColor == colorType ) and Person( favoriteColor == colorType )) // Prefix `or`: (or Color( colorType : type ) Person( favoriteColor == colorType ))
pensioner : (Person( sex == "f", age > 60 ) or Person( sex == "m", age > 65 )) (or pensioner : Person( sex == "f", age > 60 ) pensioner : Person( sex == "m", age > 65 ))
exists Person( firstName == "John") exists (Person( firstName == "John", age == 42 )) exists (Person( firstName == "John" ) and Person( lastName == "Doe" ))
not Person( firstName == "John") not (Person( firstName == "John", age == 42 )) not (Person( firstName == "John" ) and Person( lastName == "Doe" ))
rule "All full-time employees have red ID badges" when forall( USDemp : Employee( type == "fulltime" ) Employee( this == USDemp, badgeColor = "red" ) ) then // True, all full-time employees have red ID badges. end
rule "All full-time employees have red ID badges" when forall( Employee( badgeColor = "red" ) ) then // True, all full-time employees have red ID badges. end
rule "All employees have health and dental care programs" when forall( USDemp : Employee() HealthCare( employee == USDemp ) DentalCare( employee == USDemp ) ) then // True, all employees have health and dental care. end
rule "Not all employees have health and dental care" when not ( forall( USDemp : Employee() HealthCare( employee == USDemp ) DentalCare( employee == USDemp ) ) ) then // True, not all employees have health and dental care. end
rule "Validate zipcode" when Person( USDpersonAddress : address ) Address( zipcode == "23920W" ) from USDpersonAddress then // Zip code is okay. end
rule "Validate zipcode" when USDp : Person() USDa : Address( zipcode == "23920W" ) from USDp.address then // Zip code is okay. end
rule "Apply 10% discount to all items over USUSD 100 in an order" when USDorder : Order() USDitem : OrderItem( value > 100 ) from USDorder.items then // Apply discount to `USDitem`. end
when USDorder : Order() OrderItem( value > 100, order == USDorder )
rule "Assign people in North Carolina (NC) to sales region 1" ruleflow-group "test" lock-on-active true when USDp : Person() USDa : Address( state == "NC" ) from USDp.address then modify (USDp) {} // Assign the person to sales region 1. end rule "Apply a discount to people in the city of Raleigh" ruleflow-group "test" lock-on-active true when USDp : Person() USDa : Address( city == "Raleigh" ) from USDp.address then modify (USDp) {} // Apply discount to the person. end
// Do not use `from` in this way: rule R when USDl : List() String() from USDl (String() or Number()) then // Actions end // Use `from` in this way instead: rule R when USDl : List() (String() from USDl) (String() or Number()) then // Actions end
rule "Authorize withdrawal" when WithdrawRequest( USDai : accountId, USDam : amount ) from entry-point "ATM Stream" CheckingAccount( accountId == USDai, balance > USDam ) then // Authorize withdrawal. end
import org.kie.api.runtime.KieSession; import org.kie.api.runtime.rule.EntryPoint; // Create your KIE base and KIE session as usual: KieSession session = // Create a reference to the entry point: EntryPoint atmStream = session.getEntryPoint("ATM Stream"); // Start inserting your facts into the entry point: atmStream.insert(aWithdrawRequest);
import java.util.List rule "Raise priority when system has more than three pending alarms" when USDsystem : System() USDalarms : List( size >= 3 ) from collect( Alarm( system == USDsystem, status == 'pending' ) ) then // Raise priority because `USDsystem` has three or more `USDalarms` pending. end
import java.util.LinkedList; rule "Send a message to all parents" when USDtown : Town( name == 'Paris' ) USDmothers : LinkedList() from collect( Person( children > 0 ) from USDtown.getPeople() ) then // Send a message to all parents. end
accumulate( <source pattern>; <functions> [;<constraints>] )
rule "Raise alarm" when USDs : Sensor() accumulate( Reading( sensor == USDs, USDtemp : temperature ); USDmin : min( USDtemp ), USDmax : max( USDtemp ), USDavg : average( USDtemp ); USDmin < 20, USDavg > 70 ) then // Raise the alarm. end
rule "Average profit" when USDorder : Order() accumulate( OrderItem( order == USDorder, USDcost : cost, USDprice : price ); USDavgProfit : average( 1 - USDcost / USDprice ) ) then // Average profit for `USDorder` is `USDavgProfit`. end
// An implementation of an accumulator capable of calculating average values public class AverageAccumulateFunction implements org.kie.api.runtime.rule.AccumulateFunction<AverageAccumulateFunction.AverageData> { public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { } public void writeExternal(ObjectOutput out) throws IOException { } public static class AverageData implements Externalizable { public int count = 0; public double total = 0; public AverageData() {} public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { count = in.readInt(); total = in.readDouble(); } public void writeExternal(ObjectOutput out) throws IOException { out.writeInt(count); out.writeDouble(total); } } /* (non-Javadoc) * @see org.kie.api.runtime.rule.AccumulateFunction#createContext() */ public AverageData createContext() { return new AverageData(); } /* (non-Javadoc) * @see org.kie.api.runtime.rule.AccumulateFunction#init(java.io.Serializable) */ public void init(AverageData context) { context.count = 0; context.total = 0; } /* (non-Javadoc) * @see org.kie.api.runtime.rule.AccumulateFunction#accumulate(java.io.Serializable, java.lang.Object) */ public void accumulate(AverageData context, Object value) { context.count++; context.total += ((Number) value).doubleValue(); } /* (non-Javadoc) * @see org.kie.api.runtime.rule.AccumulateFunction#reverse(java.io.Serializable, java.lang.Object) */ public void reverse(AverageData context, Object value) { context.count--; context.total -= ((Number) value).doubleValue(); } /* (non-Javadoc) * @see org.kie.api.runtime.rule.AccumulateFunction#getResult(java.io.Serializable) */ public Object getResult(AverageData context) { return new Double( context.count == 0 ? 0 : context.total / context.count ); } /* (non-Javadoc) * @see org.kie.api.runtime.rule.AccumulateFunction#supportsReverse() */ public boolean supportsReverse() { return true; } /* (non-Javadoc) * @see org.kie.api.runtime.rule.AccumulateFunction#getResultType() */ public Class< ? > getResultType() { return Number.class; } }
import accumulate <class_name> <function_name>
import accumulate AverageAccumulateFunction.AverageData average rule "Average profit" when USDorder : Order() accumulate( OrderItem( order == USDorder, USDcost : cost, USDprice : price ); USDavgProfit : average( 1 - USDcost / USDprice ) ) then // Average profit for `USDorder` is `USDavgProfit`. end
rule "Find all grades for Big Data exam" when USDstudent: Student( USDplan: plan ) USDexam: Exam( course == "Big Data" ) from USDplan.exams USDgrade: Grade() from USDexam.grades then // Actions end
rule "Find all grades for Big Data exam" when Student( USDgrade: /plan/exams[course == "Big Data"]/grades ) then // Actions end
OOPExpr = [ID ( ":" | ":=" )] ( "/" | "?/" ) OOPSegment { ( "/" | "?/" | "." ) OOPSegment } ; OOPSegment = ID ["#" ID] ["[" ( Number | Constraints ) "]"]
Student( USDgrade: /plan/exams[ course == "Big Data" ]/grades )
Student( USDgrade: /plan/exams#AdvancedExam[ course == "Big Data", level > 3 ]/grades )
Student( USDgrade: /plan/exams/grades[ result > ../averageResult ] )
Student( USDexam: /plan/exams[ /grades[ result > 20 ] ] )
Student( USDgrade: /plan/exams[0]/grades )
public void setCourse(String course) { this.course = course; notifyModification(this); }
Student( USDgrade: /plan/exams[ course == "Big Data" ]/grades )
Student( USDgrade: /plan/exams[ course == "Big Data" ]?/grades )
Student( USDgrade: ?/plan/exams[ course == "Big Data" ]/grades )
Student( USDgrade: /plan?/exams[ course == "Big Data" ]?/grades )
public class School extends AbstractReactiveObject { private String name; private final List<Child> children = new ReactiveList<Child>(); 1 public void setName(String name) { this.name = name; notifyModification(); 2 } public void addChild(Child child) { children.add(child); 3 // No need to call `notifyModification()` here } }
rule "Underage" when application : LoanApplication() Applicant( age < 21 ) then application.setApproved( false ); application.setExplanation( "Underage" ); end
set<field> ( <value> )
USDapplication.setApproved ( false ); USDapplication.setExplanation( "has been bankrupt" );
modify ( <fact-expression> ) { <expression>, <expression>, }
modify( LoanApplication ) { setAmount( 100 ), setApproved ( true ) }
update ( <object, <handle> ) // Informs the decision engine that an object has changed update ( <object> ) // Causes `KieSession` to search for a fact handle of the object
LoanApplication.setAmount( 100 ); update( LoanApplication );
insert( new <object> );
insert( new Applicant() );
insertLogical( new <object> );
insertLogical( new Applicant() );
delete( <object> );
delete( Applicant );
drools.getKieRuntime().getAgenda().getAgendaGroup( "CleanUp" ).setFocus();
rule "Give 10% discount to customers older than 60" when USDcustomer : Customer( age > 60 ) then modify(USDcustomer) { setDiscount( 0.1 ) }; end rule "Give free parking to customers older than 60" when USDcustomer : Customer( age > 60 ) USDcar : Car( owner == USDcustomer ) then modify(USDcar) { setFreeParking( true ) }; end
rule "Give 10% discount to customers older than 60" when USDcustomer : Customer( age > 60 ) then modify(USDcustomer) { setDiscount( 0.1 ) }; end rule "Give free parking to customers older than 60" extends "Give 10% discount to customers older than 60" when USDcar : Car( owner == USDcustomer ) then modify(USDcar) { setFreeParking( true ) }; end
rule "Give 10% discount and free parking to customers older than 60" when USDcustomer : Customer( age > 60 ) do[giveDiscount] USDcar : Car( owner == USDcustomer ) then modify(USDcar) { setFreeParking( true ) }; then[giveDiscount] modify(USDcustomer) { setDiscount( 0.1 ) }; end
rule "Give free parking to customers older than 60 and 10% discount to golden ones among them" when USDcustomer : Customer( age > 60 ) if ( type == "Golden" ) do[giveDiscount] USDcar : Car( owner == USDcustomer ) then modify(USDcar) { setFreeParking( true ) }; then[giveDiscount] modify(USDcustomer) { setDiscount( 0.1 ) }; end
rule "Give free parking and 10% discount to over 60 Golden customer and 5% to Silver ones" when USDcustomer : Customer( age > 60 ) if ( type == "Golden" ) do[giveDiscount10] else if ( type == "Silver" ) break[giveDiscount5] USDcar : Car( owner == USDcustomer ) then modify(USDcar) { setFreeParking( true ) }; then[giveDiscount10] modify(USDcustomer) { setDiscount( 0.1 ) }; then[giveDiscount5] modify(USDcustomer) { setDiscount( 0.05 ) }; end
rule "Underage" // This is a single-line comment. when USDapplication : LoanApplication() // This is an in-line comment. Applicant( age < 21 ) then /* This is a multi-line comment in the rule actions. */ USDapplication.setApproved( false ); USDapplication.setExplanation( "Underage" ); end
1: rule "simple rule" 2: when 3: exists Person() 4: exits Student() // Must be `exists` 5: then 6: end
[ERR 101] Line 4:4 no viable alternative at input 'exits' in rule "simple rule"
1: package org.drools.examples; 2: rule // Must be `rule "rule name"` (or `rule rule_name` if no spacing) 3: when 4: Object() 5: then 6: System.out.println("A RHS"); 7: end
[ERR 101] Line 3:2 no viable alternative at input 'when'
1: rule "simple rule" 2: when 3: Student( name == "Andy ) // Must be `"Andy"` 4: then 5: end
[ERR 101] Line 0:-1 no viable alternative at input '<eof>' in rule "simple rule" in pattern Student
1: rule simple_rule 2: when 3: USDp : Person( // Must be a complete rule statement
[ERR 102] Line 0:-1 mismatched input '<eof>' expecting ')' in rule "simple rule" in pattern Person
1: package org.drools.examples; 2: 3: rule "Wrong syntax" 4: when 5: not( Car( ( type == "tesla", price == 10000 ) || ( type == "kia", price == 1000 ) ) from USDcarList ) // Must use `&&` operators instead of commas `,` 6: then 7: System.out.println("OK"); 8: end
[ERR 102] Line 5:36 mismatched input ',' expecting ')' in rule "Wrong syntax" in pattern Car [ERR 101] Line 5:57 no viable alternative at input 'type' in rule "Wrong syntax" [ERR 102] Line 5:106 mismatched input ')' expecting 'then' in rule "Wrong syntax"
1: package nesting; 2: 3: import org.drools.compiler.Person 4: import org.drools.compiler.Address 5: 6: Some text // Must be a valid DRL keyword 7: 8: rule "test something" 9: when 10: USDp: Person( name=="Michael" ) 11: then 12: USDp.name = "other"; 13: System.out.println(p.name); 14: end
[ERR 103] Line 6:0 rule 'rule_key' failed predicate: {(validateIdentifierKey(DroolsSoftKeywords.RULE))}? in rule
1: rule "simple rule" 2: when 3: eval( abc(); ) // Must not use semicolon `;` 4: then 5: end
[ERR 104] Line 3:4 trailing semi-colon not allowed in rule "simple rule"
1: rule "empty condition" 2: when 3: None // Must remove `None` if condition is empty 4: then 5: insert( new Person() ); 6: end
[ERR 105] Line 2:2 required (...)+ loop did not match anything at input 'WHEN' in rule "empty condition"