Is there way to insert fact using hibernate based on Rule LHS in drools

Question

I'm new in drools. I've found way to automatically insert fact from database based on rule's lhs in drl file.

if there is rule like this,

    1: rule "simple rule"
    2:   when
    3:     Student( name == "Andy" )
    4:   then
    5: end

Then I found fact from db using hibernate

    StudentRepository.findByName("Andy");

But, I can't know how can I use the rule's lhs in code. Please let me know there is a way and how to do it.

I almost waste 2 weeks to do this...

add my code) OnDemandMessageRuleUnit.java

package com.joel.messageRule.service;

import com.joel.messageRule.model.Daybook;
import com.joel.messageRule.model.Member;
import com.joel.messageRule.repositories.DaybookRepository;
import com.joel.messageRule.repositories.MemberRepository;
import lombok.Getter;
import org.kie.api.runtime.rule.DataSource;
import org.kie.api.runtime.rule.RuleUnit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

@Getter
@Component
public class OnDemandMessageRuleUnit implements RuleUnit {
    private DataSource<Member> members;
    private DataSource<Daybook> daybooks;
    private MemberRepository memberRepository;
    private DaybookRepository daybookRepository;
    private final Logger logger = LoggerFactory.getLogger(OnDemandMessageRuleUnit.class);

    public OnDemandMessageRuleUnit(MemberRepository memberRepository, DaybookRepository daybookRepository){
        this.memberRepository = memberRepository;
        this.daybookRepository = daybookRepository;
        this.members = DataSource.create();
        this.daybooks = DataSource.create();
    }

    @Override
    public void onStart() {
        // in this part i want to insert daybook objects which meet the condition written as rule lhs to data source or kiesession 
        logger.info("OnDemandMessageRuleUnit Started");
        for(Member m:members){
            List<Daybook> daybookList = m.getDaybooks();
            if(!daybookList.isEmpty()){
                for(Daybook d:daybookList){
                    daybooks.insert(d);
                }
            }
        }
    }

    @Override
    public void onEnd() {
        logger.info("OnDemandMessageRuleUnit Ended");
        try{
            for(Member m:members){
                memberRepository.save(m);
            }
            for(Daybook d:daybooks){
                daybookRepository.save(d);
            }
        }
        catch (NullPointerException e){
            e.printStackTrace();
            throw e;
        }
        finally {

        }
    }
}

complimentMessage.drl

package com.joel.messageRule.service
unit OnDemandMessageRuleUnit

import java.lang.Number;
import com.joel.messageRule.model.*;
import org.slf4j.Logger;

rule "complimentMessage"
    dialect "mvel"
    when
        $receiver : Member(cumulativeDaybookRecord >= 3) from members
    then
        logger.info($receiver.getName() + "님에게 칭찬 메시지를 전송하였습니다.");
end

So, i read Member(cumulativeDaybookRecord >= 3) from rule or Production Memory or Node Memory, make query "select * from Member where cumulativeDaybookRecord >= 3" and insert the result to Working Memory

Answer 1

Hi you need insert your database repository in Working memory. Let's say your Hibernate return only one Student object then rule drl as follow.

rule "simple rule"
       when
         $studentRepository : StudentRepository(  )  
        $studentModel :Student() from $studentRepository.findByName("Andy")
       then
    end

And add your student database repository like below

@Autowired
private StudentRepository studentRepository ;
//
//
kieSession.insert(studentRepository );
kieSession.fireAllRules();

And here is another example if your database repository returns Students lists then needs to modify the rules

rule "simple rule"
       when
         $studentRepository : StudentRepository(  )  
         $studentList : ArrayList() from collect( Student() from $studentRepository.findStudentsByDepartment("Computer Science") )  
         $student : Student( name == "Andy"  ) from $studentList 
         
       then
    end

So similar way to you use as follow

rule "complimentMessage"
    dialect "mvel"
    when
        $memberRepository : MemberRepository(  ) 
        $receiver : Member() from $memberRepository.findMemberBycumulativeDaybookRecord (3)
    then
        logger.info($receiver.getName() + "님에게 칭찬 메시지를 전송하였습니다.");
end

And in Member Repository

@Query(value = "select * from Member where cumulativeDaybookRecord >= ?1", 
            nativeQuery = true)
    Member findMemberBycumulativeDaybookRecord(int cumulativeDaybookRecord);

Member repository and loaded into working memory

@Autowired
private MemberRepository memberRepository;

//
//
kieSession.insert(memberRepository );
kieSession.fireAllRules();

Answer 2

You're on the right track, but your RuleUnit needs some tweaking.

The purpose of the RuleUnit, in the way we're using it here, is to provide the Members in a way that the person who is writing the rule doesn't need to understand how the members are gotten from the database. Your RuleUnit is only missing the getMembers() method in order for your rule to work.

Your rule says this:

$receiver : Member(cumulativeDaybookRecord >= 3) from members

This is not going to do a select * from members where cumulativeDaybookRecord >= 3. This is going to do a select * from members and then apply the cumulative daybook record filter in memory when Drools is evaluating if the rule should be triggered. That way you can have one rule for >= 3, another for == 0, and so on, which will all work against the same set of members.

Really it comes down to how you define your public Datasource<Member> getMembers() method, which you've not implemented. This is the logic that makes a set of Members available to your rules. You can implement it in any way that you want using hibernate as long as it results in a collection of Member instances. However that method takes no arguments.

If you want to apply the filter to the database query, then the RuleUnit is the wrong pattern to be using. The idea of the RuleUnit as a datasource is that it provides you a collection of data, and then you can write multiple rules against that data. So you could write rules against different cumulative daybook record amounts, or against the member name, or their join date, or whatever -- all using the same data source. The other RuleUnit methods would allow you to safely wrap that database interaction with proper start/stop handling, which would be useful for connection or transaction management.

But if you actually want to do multiple database queries with different filters on the query itself, this is not the appropriate structure for you to use. You're going to have to likely do actual calls against the repository like Thilakar Raj suggests in his answer (though I very much do not recommend doing database calls in rules like that because of how Drools evaluates rules.) If the problem is that the people writing the rules aren't programmers, then the answer might be to write a custom wrapper for the repository with special methods to applying filters or pre-made filters, and then passing that into working memory.