So far, we've seen ways to write conditions in our rules that will get triggered for every single match against the working memory. Let's analyze a simple rule to fully understand this mechanism:

rule "Simple order condition"
     when $o: Order()
     then System.out.println("order found: " + $o);
   end

The previous rule is defined in such a way that if we insert 50 orders in the KieSession, we will trigger this rule 50 times when we fire the rules. This is useful when we want to do something on each element that matches a condition. However, if we want to act against all the elements that match a condition at once, we need an extra syntax to help us. This is where the collect keyword comes into play.

The "collect" keyword is used to find all the elements that match a specific condition and group them into a collection. Later on, this collection can be assigned to a variable or submitted to further conditions, as follows:

rule "Grouping orders"
     when $list: List() from collect(Order())
     then
          System.out.println("we've found " +$list.size() + " orders");
   end

In the previous case, if we insert 50 orders to KieSession and then fire the rules, the rule will fire only once, producing a list of 50 orders. However, if we fire all the rules without inserting any orders first, this rule would still fire returning an empty list in the $list variable. To avoid so, we should add conditions in the List object by writing it as follows:

$list: List(size > 0) from collect(Order())

The collect keyword can be combined with the from clause to create new collections from different sources. It is very useful whenever we can find objects through the rule conditions and add them directly to a collection.

In the previous section, we saw that the collect keyword allows us to gather information directly from a source into a collection. This is a very useful component when we already have the elements as we need them to be somewhere accessible in the working memory. However, sometimes we need to apply transformations to the data that matches a condition. For these cases, the accumulate keyword is used to transform every match of a condition to a specific type of data.

You can think of the accumulate keyword as a collect on steroids. You not only get to group every item that matches a condition, but also extrapolate the data from these elements in a specific programmatic way. Some common examples where the accumulate keyword is used are counting elements that match a specific condition, get average values of an attribute of certain type of objects, and to find the average, minimum, or maximum values of a specific attribute in a condition.

Perhaps an example could help clarify the use of accumulate. In the previous rules, we've used a method of the Order object, called getTotalItems, to return the count of items that we were purchasing in this order. So far, this has been the only way we would have to get this information from the Order object. However, using accumulate, we can obtain this information while filtering specific items using the full power of rules. Let's see this in an example:

rule "10+ items with sale price over 20 get discount"
       when$o: Order($lines: orderLines)
           Number(intValue >= 10) from accumulate(OrderLine(item.salePrice > 20.00, $q: quantity) from $lines,init(int count = 0;),action(count += $q),reverse(count -= $q),result(count))
       then
           $o.increaseDiscount(0.05);
   end

We've got a lot to explain from the previous rule. It's main objective is to get the total number of items in the order that follows a specific condition: having a sale price value higher than 20. The getTotalItems method would be able to give us a count of all the items, however, it wouldn't be able to filter through them. The accumulate here, however, would allow us to apply a condition to the elements and apply a predicate to transform the elements that match the accumulate condition in the information that we need. Let's analyze the parts of the accumulate to fully understand its structure, as follows:

The following four parts of the accumulate (init, action, reverse, and result) contain information about what to do whenever we find an object that matches the condition:

Although this is the full syntax for using accumulate, it doesn't necessarily have to be this complex every single time. Drools provides a set of predefined accumulate functions that you can directly use in your rules. Here's the previous rule that is rewritten to show how to use one of these built-in functions:

rule "10+ items with sale price over 20 get discount"
       when
           $o: Order($lines: orderLines)
           Number(intValue >= 10) from accumulate(OrderLine(item.salePrice > 20.00, $q: quantity) from $lines,sum($q))
       then
           $o.increaseDiscount(0.05);
   end

The already provided accumulate functions are as follows:

Using a predefined function is preferred as it makes the rule more readable and is less prone to errors. You can even use many of them at once, one after the other, separated by a comma, as shown in the following example:

rule "multi-function accumulate example"
     when accumulate(Order($total: total),$maximum: max($total),$minimum: min($total),$average: avg($total))
     then //...
   end

The previous rule stores the maximum, minimum, and average of the totals of all the orders in the working memory. As you can see, the from clause is not mandatory for the accumulate keyword. It is even discouraged with multifunction accumulates as it might return completely different types of objects (such as Lists and Numbers).

If you want to do an accumulate in a way that is not provided by these functions, Drools provides an API to create our own accumulate functions, similar to that used to create our own custom operators. We will see more about the API in the next chapter.

The previous sections have been about how to extract data, however, we've been very straightforward with the order of our conditions. Always every condition has been separated by a comma and the execution of the rule was basically each condition followed by an implicit AND. It is time to see how to apply more complex boolean operations to our rules.

We've seen how to use boolean operations in a single object, checking whether its internal attributes matched the specific combinations of conditions. We'll see now how to do the same with different objects and how it would get translated to the rule language.

rule "warn about empty working memory"
    when
           not(Order() or Item())
       then
           System.out.println("we don't have elements");
   end

rule "warn about empty working memory"
    when
           not(Order())
           not(Item())
       then
           System.out.println("we don't have elements");
   end

rule "with exists"
  when 
    exists(Order())
  then
    System.out.prinltn(
      "We have orders");
end

rule "without exists"
  when 
    $o: Order()
  then
    System.out.println($o);
end

rule "make sure all orders have at least one line"
       when
           exists(Order())
           forall(Order()Order(orderLines.size() > 0)
           )
       then
           System.out.println("all orders have lines");
   end