Drools文档（八） 规则语言参考

import some.package.StockTick

declare StockTick
    @role( event )
end

declare StockTick
    @role( event )

    datetime : java.util.Date
    symbol : String
    price : double
end

``@timestamp( <attributeName> )``

declare VoiceCall
    @role( event )
    @timestamp( callDateTime )
end

``@duration( <attributeName> )``

declare VoiceCall
    @role( event )
    @timestamp( callDateTime )
    @duration( callDuration )
end

``@expires( <timeOffset> )``

``[#d][#h][#m][#s][#[ms]]``

declare VoiceCall
    @role( event )
    @timestamp( callDateTime )
    @duration( callDuration )
    @expires( 1h35m )
end

declare Person
    @propertyChangeSupport
end

declare Person
    firstName : String @key
    lastName : String @key
    age : int
end

``Person person = new Person( "John", "Doe" );``

declare Cheese
    name : String
    shop : String
    price : int
end

declare Cheese
    name : String @position(1)
    shop : String @position(2)
    price : int @position(0)
end

Cheese( "stilton", "Cheese Shop", p; )
Cheese( "stilton", "Cheese Shop"; p : price )
Cheese( "stilton"; shop == "Cheese Shop", p : price )
Cheese( name == "stilton"; shop == "Cheese Shop", p : price )

declare Cheese
    name : String
    shop : String @position(2)
    price : int @position(0)
end

declare SeasonedCheese extends Cheese
    year : Date @position(0)
    origin : String @position(6)
    country : String
end

Person()

Object() // 匹配工作内存中的所有对象

Person( age == 100 )

rule ...
when
    $p : Person()
then
    System.out.println( "Person " + $p );
end

``Person( 5 < 6 )  // 只是一个例子，因为这样的约束在实际模式中是无用的

Person( age == 50 )

// this is the same as:
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 exists, this falls back to:
Person( age() == 50 )

Person( address.houseNumber == 50 )

// this is the same as:
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``

// Similar to: java.util.Objects.equals(person.getFirstName(), "John")
// so (because "John" is not null) similar to:
// "John".equals(person.getFirstName())
Person( firstName == "John" )

``// Similar to: !java.util.Objects.equals(person.getFirstName(), "John")
Person( firstName != "John" )``

``Person( age == "10" ) // "10" is coerced to 10``

// Person is at least 50 and weighs at least 80 kg
Person( age > 50, weight > 80 )

// Person is at least 50, weighs at least 80 kg and is taller than 2 meter.
Person( age > 50, weight > 80, height > 2 )

Person( ( age > 50, weight > 80 ) || height > 2 ) // Do NOT do this: compile error

// Use this instead
Person( ( age > 50 && weight > 80 ) || height > 2 )

// 2 persons of the same age
Person( $firstAge : age ) // binding
Person( age == $firstAge ) // constraint expression

// Not recommended
Person( $age : age * 2 < 100 )

// Recommended (separates bindings and constraint expressions)
Person( age * 2 < 100, $age : age )

Person( $age := age )
Person( $age := age)

Person( name == "mark", address.city == "london", address.country == "uk" )

Person( name == "mark", address.( city == "london", country == "uk") )

Person( name == "mark", address#LongAddress.country == "uk" )

Person( name == "mark", address#org.domain.LongAddress.country == "uk" )

Person( name == "mark", address#LongAddress.country#DetailedCountry.population > 10000000 )

Person( name == "mark", address instanceof LongAddress, address.country == "uk" )

``Cheese( bestBefore < "27-Oct-2009" )``

// Same as childList(0).getAge() == 18
Person( childList[0].age == 18 )

// Same as credentialMap.get("jsmith").isValid()
Person( credentialMap["jsmith"].valid )

// 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( firstName < $otherFirstName )``

``Person( birthDate < $otherBirthDate )``

``Person( $streetName : address!.street )``

``Person( address != null, $streetName : address.street )``

``Cheese( type matches "(Buffalo)?\\S*Mozzarella" )``

``Cheese( type not matches "(Buffalo)?\\S*Mozzarella" )``

CheeseCounter( cheeses contains "stilton" ) // contains with a String literal
CheeseCounter( cheeses contains $var ) // contains with a variable

Cheese( name contains "tilto" )
Person( fullName contains "Jr" )
String( this contains "foo" )

CheeseCounter( cheeses not contains "cheddar" ) // not contains with a String literal
CheeseCounter( cheeses not contains $var ) // not contains with a variable

Cheese( name not contains "tilto" )
Person( fullName not contains "Jr" )
String( this not contains "foo" )

``CheeseCounter( cheese memberOf $matureCheeses )``

``CheeseCounter( cheese not memberOf $matureCheeses )``

// match cheese "fubar" or "foobar"
Cheese( name soundslike ‘foobar‘ )

Message( routingValue str[startsWith] "R1" )

Message( routingValue str[endsWith] "R2" )

Message( routingValue str[length] 17 )

Person( $cheese : favouriteCheese )
Cheese( type in ( "stilton", "cheddar", $cheese ) )

``n", "cheddar", $cheese ) )``

Person( girlAge : age, sex = "F" )
Person( eval( age == girlAge + 2 ), sex = ‘M‘ ) // eval() is actually obsolete in this example

//infixAnd
Cheese( cheeseType : type ) and Person( favouriteCheese == cheeseType )

//infixAnd with grouping
( Cheese( cheeseType : type ) and
  ( Person( favouriteCheese == cheeseType ) or
    Person( favouriteCheese == cheeseType ) )

(and Cheese( cheeseType : type )
     Person( favouriteCheese == cheeseType ) )

when
    Cheese( cheeseType : type )
    Person( favouriteCheese == cheeseType )
then
    ...

//infixOr
Cheese( cheeseType : type ) or Person( favouriteCheese == cheeseType )

//infixOr with grouping
( Cheese( cheeseType : type ) or
  ( Person( favouriteCheese == cheeseType ) and
    Person( favouriteCheese == cheeseType ) )

(or Person( sex == "f", age > 60 )
    Person( sex == "m", age > 65 )

``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 ) )

not Bus()

// Brackets are optional:
not Bus(color == "red")
// Brackets are optional:
not ( Bus(color == "red", number == 42) )
// "not" with nested infix and - two patterns,
// brackets are requires:
not ( Bus(color == "red") and
      Bus(color == "blue") )

``exists Bus()``

exists Bus(color == "red")
// brackets are optional:
exists ( Bus(color == "red", number == 42) )
// "exists" with nested infix and,
// brackets are required:
exists ( Bus(color == "red") and
         Bus(color == "blue") )

rule "All English buses are red"
when
    forall( $bus : Bus( type == ‘english‘)
                   Bus( this == $bus, color = ‘red‘ ) )
then
    // all English buses are red
end

rule "All Buses are Red"
when
    forall( Bus( color == ‘red‘ ) )
then
    // all Bus facts are red
end

rule "all employees have health and dental care programs"
when
    forall( $emp : Employee()
            HealthCare( employee == $emp )
            DentalCare( employee == $emp )
          )
then
    // all employees have health and dental care
end

rule "not all employees have health and dental care"
when
    not ( forall( $emp : Employee()
                  HealthCare( employee == $emp )
                  DentalCare( employee == $emp ) )
        )
then
    // not all employees have health and dental care
end

not(p1 and not(and p2 p3...))

rule "validate zipcode"
when
    Person( $personAddress : address )
    Address( zipcode == "23920W") from $personAddress
then
    // zip code is ok
end

rule "validate zipcode"
when
    $p : Person( )
    $a : Address( zipcode == "23920W") from $p.address
then
    // zip code is ok
end

rule "apply 10% discount to all items over US$ 100,00 in an order"
when
    $order : Order()
    $item  : OrderItem( value > 100 ) from $order.items
then
    // apply discount to $item
end

rule "Assign people in North Carolina (NC) to sales region 1"
ruleflow-group "test"
lock-on-active true
when
    $p : Person( )
    $a : Address( state == "NC") from $p.address
then
    modify ($p) {} // Assign person to sales region 1 in a modify block
end

rule "Apply a discount to people in the city of Raleigh"
ruleflow-group "test"
lock-on-active true
when
    $p : Person( )
    $a : Address( city == "Raleigh") from $p.address
then
    modify ($p) {} // Apply discount to person in a modify block
end

rule "Assign people in North Carolina (NC) to sales region 1"
ruleflow-group "test"
lock-on-active true
when
    $p : Person(address.state == "NC" )
then
    modify ($p) {} // Assign person to sales region 1 in a modify block
end

rule "Apply a discount to people in the city of Raleigh"
ruleflow-group "test"
lock-on-active true
when
    $p : Person(address.city == "Raleigh" )
then
    modify ($p) {} //Apply discount to person in a modify block
end

rule "Assign people in North Carolina (NC) to sales region 1"
ruleflow-group "test"
lock-on-active true
when
    $p : Person($addresses : addresses)
    exists (Address(state == "NC") from $addresses)
then
    modify ($p) {} // Assign person to sales region 1 in a modify block
end

rule "Apply a discount to people in the city of Raleigh"
ruleflow-group "test"
lock-on-active true
when
    $p : Person($addresses : addresses)
    exists (Address(city == "Raleigh") from $addresses)
then
    modify ($p) {} // Apply discount to person in a modify block
end

rule "Assign people in North Carolina (NC) to sales region 1"
ruleflow-group "test"
lock-on-active true
when
    $assessment : Assessment()
    $p : Person()
    $addresses : List() from $p.addresses
    exists (Address( state == "NC") from $addresses)
then
    modify ($assessment) {} // Modify assessment in a modify block
end

rule "Apply a discount to people in the city of Raleigh"
ruleflow-group "test"
lock-on-active true
when
    $assessment : Assessment()
    $p : Person()
    $addresses : List() from $p.addresses
    exists (Address( city == "Raleigh") from $addresses)
then
    modify ($assessment) {} // Modify assessment in a modify block
end

``rule R when
  $l : List( )
  String() from $l
  (String() or Number())
then end``

``rule R when
  $l : List( )
  (String() from $l)
  (String() or Number())
then end``

import java.util.ArrayList

rule "Raise priority if system has more than 3 pending alarms"
when
    $system : System()
    $alarms : ArrayList( size >= 3 )
              from collect( Alarm( system == $system, status == ‘pending‘ ) )
then
    // Raise priority, because system $system has
    // 3 or more alarms pending. The pending alarms
    // are $alarms.
end

import java.util.LinkedList;

rule "Send a message to all mothers"
when
    $town : Town( name == ‘Paris‘ )
    $mothers : LinkedList()
               from collect( Person( gender == ‘F‘, children > 0 )
                             from $town.getPeople()
                           )
then
    // send a message to all mothers
end

accumulate( <source pattern>; <functions> [;<constraints>] )

rule "Raise alarm"
when
    $s : Sensor()
    accumulate( Reading( sensor == $s, $temp : temperature );
                $min : min( $temp ),
                $max : max( $temp ),
                $avg : average( $temp );
                $min < 20, $avg > 70 )
then
    // raise the alarm
end

rule "Average profit"
when
    $order : Order()
    accumulate( OrderItem( order == $order, $cost : cost, $price : price );
                $avgProfit : average( 1 - $cost / $price ) )
then
    // average profit for $order is $avgProfit
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 some.package.VarianceFunction variance

rule "Calculate Variance"
when
    accumulate( Test( $s : score ), $v : variance( $s ) )
then
    // the variance of the test scores is $v
end

drools.accumulate.function.variance = some.package.VarianceFunction

rule "Apply 10% discount to orders over US$ 100,00"
when
    $order : Order()
    $total : Number( doubleValue > 100 )
             from accumulate( OrderItem( order == $order, $value : value ),
                              sum( $value ) )
then
    // apply discount to $order
end

rule "Person names"
when
  $x : Object() from accumulate(MyPerson( $val : name );
                                collectList( $val ) )
then
  // $x is a List
end

rule "Iterate the numbers"
when
    $xs : List()
    $x : Integer() from $xs
then
  // $x matches and binds to each Integer in the collection
end

<result pattern> from accumulate( <source pattern>,
                                  init(<init code>),
                                  action( <action code> ),
                                  reverse( <reverse code> ),
                                  result( <result expression> ) )

rule "Apply 10% discount to orders over US$ 100,00"
when
    $order : Order()
    $total : Number( doubleValue > 100 )
             from accumulate( OrderItem( order == $order, $value : value ),
                              init( double total = 0; ),
                              action( total += $value; ),
                              reverse( total -= $value; ),
                              result( total ) )
then
    // apply discount to $order
end

rule "Accumulate using custom objects"
when
    $person   : Person( $likes : likes )
    $cheesery : Cheesery( totalAmount > 100 )
                from accumulate( $cheese : Cheese( type == $likes ),
                                 init( Cheesery cheesery = new Cheesery(); ),
                                 action( cheesery.addCheese( $cheese ); ),
                                 reverse( cheesery.removeCheese( $cheese ); ),
                                 result( cheesery ) );
then
    // do something
end