The first type of data source we are going to cover resembles, in some ways, a decision table. When working with rule templates, the data we want to use to generate the concrete rules can be stored in a spreadsheet file. We have already discussed the benefits of using spreadsheets, especially for non-technical users.

As the input of our rule template, a spreadsheet like the following one could be used:

The preceding spreadsheet contains only the necessary data for the template, plus some useful headers for the person who has to edit this table. The spreadsheet does not contain any information regarding the template that has to be used nor the structure of the rules that need to be generated.

In order to convert this spreadsheet into DRL, we are going to use the template file we have previously introduced (customer-classification-simple.drt) and the createKieSessionFromDRL()helper function:

        InputStream template = RuleTemplatesTest.class.getResourceAsStream("/chapter07/template-dtable/customer-classification-simple.drt");
        InputStream data = RuleTemplatesTest.class.getResourceAsStream("/chapter07/template-dtable/template-data.xls");        
        ExternalSpreadsheetCompiler converter = new ExternalSpreadsheetCompiler();
        String drl = converter.compile(data, template, 3, 2);        
        KieSession ksession = this.createKieSessionFromDRL(drl);

The first two lines of the code are getting the template and data files as InputStream instances. The fourth line is using an instance of the helper class ExternalSpreadsheetCompiler to convert the template file and the data in the spreadsheet into DRL. The compile() method in ExternalSpreadsheetCompiler takes four arguments: the data, the template, and the row and column inside the spreadsheet where the data starts. In this case, the data starts in row 3 and column 2 (B).

Another way to provide the data to a template is by using a two-dimensional array of Strings. In this case, the first dimension of the array is used as the row, and the second dimension as the column:

        InputStream template = RuleTemplatesTest.class.getResourceAsStream("/chapter07/template-dtable/customer-classification-simple.drt");
        
        DataProvider dataProvider = new ArrayDataProvider(new String[][]{
            new String[]{"18", "21", "NA", "NA"},
            new String[]{"22", "30", "NA", "BRONZE"},
            new String[]{"31", "40", "NA", "SILVER"},
            new String[]{"41", "150", "NA", "GOLD"},
        });
        
        DataProviderCompiler converter = new DataProviderCompiler();
        String drl = converter.compile(dataProvider, template);
                
        KieSession ksession = this.createKieSessionFromDRL(drl);

The preceding code shows how an instance of the DataProviderCompiler class can be used to process a template using a two-dimensional array of Strings as the data source. The data is encapsulated inside an ArrayDataProvider instance. The ArrayDataProvider class implements the DataProvider interface. If you have a special, custom source of information that needs to be fed into your rule template, you could implement your own DataProvider and connect it with the template using a DataProviderCompiler.

A more object-oriented friendly way to present the data to a template is by using objects as the model. Instead of a two-dimensional array of Strings, we could use a collection of objects to hold the data required by our templates. When objects are used as the data source of a template, the name of the variables defined in the template must match the name of the attributes in our model class:

As an example, let's create a class to contain the data for our classification scenario:

public class ClassificationTemplateModel {
    
    private int minAge;
    private int maxAge;
    private Customer.Category previousCategory;
    private Customer.Category newCategory;

 //constructors, getters and setters
}

An instance of this class will correspond to a rule after the template is processed. Note that the names of the attributes of this class correspond to the name of the variables in the template header:

        InputStream template = RuleTemplatesTest.class.getResourceAsStream("/chapter07/template-dtable/customer-classification-simple.drt");
        
        List<ClassificationTemplateModel> data = new ArrayList<>();
        
        data.add(new ClassificationTemplateModel(18, 21, Customer.Category.NA, Customer.Category.NA));
        data.add(new ClassificationTemplateModel(22, 30, Customer.Category.NA, Customer.Category.BRONZE));
        data.add(new ClassificationTemplateModel(31, 40, Customer.Category.NA, Customer.Category.SILVER));
        data.add(new ClassificationTemplateModel(41, 150, Customer.Category.NA, Customer.Category.GOLD));
        
        ObjectDataCompiler converter = new ObjectDataCompiler();
        String drl = converter.compile(data, template);
                
        KieSession ksession = this.createKieSessionFromDRL(drl);

The preceding code shows how a List of ClassificationTemplateModel objects is used as the data source for the template. In this case, an instance of the ObjectDataCompiler class is used to process the template and the list of objects.

The last option we are going to be covering to process a template file is using SQL result sets as the data source. By SQL result sets we mean the java.sql.ResultSet class. A ResultSet class can be obtained in multiple ways using—for example, JDBC. Even if we could easily convert a ResultSet into a two-dimensional array, or a collection of objects, and use one of the previously introduced ways of processing a template, Drools already provides us with a way to deal directly with ResultSet instances.

Let's assume we have the following table, called ClassificationRules, inside a database:

If we want to use the information in that table to generate DRL using a rule template, we can use the following code:

        Connection conn = //get a connection to our DB
        Statement sta = conn.createStatement();
        ResultSet rs = sta.executeQuery("SELECT minAge, maxAge, previousCategory, newCategory " +
                                        " FROM ClassificationRules");

        final ResultSetGenerator converter = new ResultSetGenerator();
        final String drl = converter.compile(rs, template);

The previous example uses standard JDBC classes, such as Connection, Statement, and ResultSet. This code executes a query against the ClassificationRules table and gets its result as a ResultSet. Then, using Drools' ResultSetGenerator class, the ResultSet and the template are converted into DRL.

It is important to notice that, even though Drools Templates comes with a handy set of functions, we can still use any other template engine, such as Velocity (https://velocity.apache.org/), or StringTemplate (http://www.stringtemplate.org/). Of course, we will not have any of the DataProvider classes, but remember that the ultimate goal of these classes is the generation of DRL code. And, after all, DRL is just plain text; so we can use whatever technique or framework we want.

Let's now move to the last topic of this chapter, which will teach us how to integrate Drools with PMML resources to allow non-rule based knowledge assets to be used inside the rule engine.