Merge branch 'feature/join-condition-functions' into 'development'

support function on join conditions

See merge request rml/proc/rmlmapper-java!26

buildNumber.properties

@@ -1,3 +1,3 @@
 #maven.buildNumber.plugin properties file
-#Mon Aug 27 13:58:09 CEST 2018
+#Tue Aug 28 14:48:59 CEST 2018
 buildNumber0=45

src/main/java/be/ugent/rml/ApplyTemplateFunctionFactory.java

@@ -1,7 +1,8 @@
 package be.ugent.rml;
 
 import be.ugent.rml.functions.ApplyTemplateFunction;
-import be.ugent.rml.functions.StaticFunctionExecutor;
+import be.ugent.rml.functions.SingleRecordFunctionExecutor;
+import be.ugent.rml.functions.StaticSingleRecordFunctionExecutor;
 import be.ugent.rml.term.NamedNode;
 import be.ugent.rml.term.Term;
 
@@ -11,19 +12,19 @@
 
 public class ApplyTemplateFunctionFactory {
 
-    static StaticFunctionExecutor generate(String genericTemplate, Term termType) {
+    static SingleRecordFunctionExecutor generate(String genericTemplate, Term termType) {
         return ApplyTemplateFunctionFactory.generate(genericTemplate, termType.equals(new NamedNode(NAMESPACES.RR + "IRI")));
     }
 
-    static StaticFunctionExecutor generate(String genericTemplate, boolean encodeURI) {
+    static SingleRecordFunctionExecutor generate(String genericTemplate, boolean encodeURI) {
         HashMap<String, List<Template>> parameters = new HashMap<>();
         ArrayList<Template> temp = new ArrayList<>();
         temp.add(Utils.parseTemplate(genericTemplate));
         parameters.put("_TEMPLATE", temp);
         return new ApplyTemplateFunction(parameters, encodeURI);
     }
 
-    static StaticFunctionExecutor generateWithConstantValue(String value) {
+    static SingleRecordFunctionExecutor generateWithConstantValue(String value) {
         HashMap<String, List<Template>> parameters = new HashMap<>();
         List<Template> temp = new ArrayList<>();
         Template temp2 = new Template();

src/main/java/be/ugent/rml/Executor.java

@@ -1,7 +1,9 @@
 package be.ugent.rml;
 
 import be.ugent.rml.functions.FunctionLoader;
-import be.ugent.rml.functions.JoinConditionFunction;
+import be.ugent.rml.functions.FunctionUtils;
+import be.ugent.rml.functions.JoinConditionFunctionExecutor;
+import be.ugent.rml.functions.MultipleRecordsFunctionExecutor;
 import be.ugent.rml.records.Record;
 import be.ugent.rml.records.RecordsFactory;
 import be.ugent.rml.store.QuadStore;
@@ -164,11 +166,11 @@ private void generateQuad(ProvenancedTerm subject, ProvenancedTerm predicate, Pr
         this.resultingTriples.addQuad(subject.getTerm(), predicate.getTerm(), object.getTerm(), g);
     }
 
-    private List<ProvenancedTerm> getIRIsWithConditions(Record record, Term triplesMap, List<JoinConditionFunction> conditions) throws IOException {
+    private List<ProvenancedTerm> getIRIsWithConditions(Record record, Term triplesMap, List<MultipleRecordsFunctionExecutor> conditions) throws IOException {
         ArrayList<ProvenancedTerm> goodIRIs = new ArrayList<ProvenancedTerm>();
         ArrayList<List<ProvenancedTerm>> allIRIs = new ArrayList<List<ProvenancedTerm>>();
 
-        for (JoinConditionFunction condition : conditions) {
+        for (MultipleRecordsFunctionExecutor condition : conditions) {
             allIRIs.add(this.getIRIsWithTrueCondition(record, triplesMap, condition));
         }
 
@@ -189,7 +191,7 @@ private List<ProvenancedTerm> getIRIsWithConditions(Record record, Term triplesM
         return goodIRIs;
     }
 
-    private List<ProvenancedTerm> getIRIsWithTrueCondition(Record child, Term triplesMap, JoinConditionFunction condition) throws IOException {
+    private List<ProvenancedTerm> getIRIsWithTrueCondition(Record child, Term triplesMap, MultipleRecordsFunctionExecutor condition) throws IOException {
         Mapping mapping = this.mappings.get(triplesMap);
 
         //iterator over all the records corresponding with @triplesMap
@@ -200,7 +202,11 @@ private List<ProvenancedTerm> getIRIsWithTrueCondition(Record child, Term triple
         for (int i = 0; i < records.size(); i++) {
             Record parent = records.get(i);
 
-            if (condition.execute(child, parent)) {
+            HashMap<String, Record> recordsMap = new HashMap<>();
+            recordsMap.put("child", child);
+            recordsMap.put("parent", parent);
+
+            if (FunctionUtils.isResultsTrue(condition.execute(recordsMap))) {
                 ProvenancedTerm subject = this.getSubject(triplesMap, mapping, parent, i);
                 iris.add(subject);
             }

src/main/java/be/ugent/rml/PredicateObjectGraphGenerator.java

@@ -1,6 +1,7 @@
 package be.ugent.rml;
 
-import be.ugent.rml.functions.JoinConditionFunction;
+import be.ugent.rml.functions.JoinConditionFunctionExecutor;
+import be.ugent.rml.functions.MultipleRecordsFunctionExecutor;
 import be.ugent.rml.term.Term;
 import be.ugent.rml.termgenerator.TermGenerator;
 
@@ -13,13 +14,13 @@ public class PredicateObjectGraphGenerator {
     private final TermGenerator predicateGenerator;
     private final TermGenerator objectGenerator;
     private final TermGenerator graphGenerator;
-    private final List<JoinConditionFunction> joinConditions;
+    private final List<MultipleRecordsFunctionExecutor> joinConditions;
     private Term parentTriplesMap;
 
     public PredicateObjectGraphGenerator(TermGenerator predicateGenerator, TermGenerator objectGenerator, TermGenerator graphGenerator) {
         this.graphGenerator = graphGenerator;
         this.predicateGenerator = predicateGenerator;
-        this.joinConditions = new ArrayList<JoinConditionFunction>();
+        this.joinConditions = new ArrayList<MultipleRecordsFunctionExecutor>();
         this.objectGenerator = objectGenerator;
     }
 
@@ -31,15 +32,15 @@ public Term getParentTriplesMap() {
         return parentTriplesMap;
     }
 
-    public List<JoinConditionFunction> getJoinConditions() {
+    public List<MultipleRecordsFunctionExecutor> getJoinConditions() {
         return joinConditions;
     }
 
     public void setParentTriplesMap(Term parentTriplesMap) {
         this.parentTriplesMap = parentTriplesMap;
     }
 
-    public void addJoinCondition(JoinConditionFunction condition) {
+    public void addJoinCondition(MultipleRecordsFunctionExecutor condition) {
         joinConditions.add(condition);
     }
 

src/main/java/be/ugent/rml/cli/Main.java

@@ -3,6 +3,7 @@
 import be.ugent.rml.*;
 import be.ugent.rml.functions.FunctionLoader;
 import be.ugent.rml.functions.lib.GrelProcessor;
+import be.ugent.rml.functions.lib.IDLabFunctions;
 import be.ugent.rml.records.RecordsFactory;
 import be.ugent.rml.store.Quad;
 import be.ugent.rml.store.QuadStore;
@@ -111,6 +112,7 @@ public static void main(String [] args) {
                 } else {
                     Map<String, Class> libraryMap = new HashMap<>();
                     libraryMap.put("GrelFunctions", GrelProcessor.class);
+                    libraryMap.put("IDLabFunctions", IDLabFunctions.class);
                     FunctionLoader functionLoader = new FunctionLoader(null, null, libraryMap);
                     executor = new Executor(rmlStore, factory, functionLoader);
                 }

src/main/java/be/ugent/rml/functions/AbstractSingleRecordFunctionExecutor.java

@@ -0,0 +1,19 @@
+package be.ugent.rml.functions;
+
+import be.ugent.rml.records.Record;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+
+public abstract class AbstractSingleRecordFunctionExecutor implements SingleRecordFunctionExecutor {
+
+    protected MultipleRecordsFunctionExecutor functionExecutor;
+
+    public List<?> execute(Record record) throws IOException {
+        HashMap<String, Record> recordsMap = new HashMap<>();
+        recordsMap.put("_default", record);
+
+        return this.functionExecutor.execute(recordsMap);
+    }
+}

src/main/java/be/ugent/rml/functions/ApplyTemplateFunction.java

@@ -7,13 +7,13 @@
 import java.util.List;
 import java.util.Map;
 
-public class ApplyTemplateFunction extends StaticFunctionExecutor {
+public class ApplyTemplateFunction implements SingleRecordFunctionExecutor {
 
     private boolean encodeURI;
+    private Map<String, List<Template>> parameters;
 
     public ApplyTemplateFunction(Map<String, List<Template>> parameters, boolean encodeURI) {
-        super(null, parameters);
-
+        this.parameters = parameters;
         this.encodeURI = encodeURI;
     }
 

src/main/java/be/ugent/rml/functions/DynamicFunctionExecutor.java → src/main/java/be/ugent/rml/functions/DynamicMultipleRecordsFunctionExecutor.java

@@ -9,19 +9,20 @@
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
-public class DynamicFunctionExecutor implements FunctionExecutor {
+public class DynamicMultipleRecordsFunctionExecutor implements MultipleRecordsFunctionExecutor {
 
-    private List<ParameterValuePair> parameterValuePairs;
+    private List<ParameterValueOriginPair> parameterValuePairs;
     private FunctionLoader functionLoader;
-    private StaticFunctionExecutor fn;
 
-    public DynamicFunctionExecutor(List<ParameterValuePair> parameterValuePairs, FunctionLoader functionLoader) {
+    public DynamicMultipleRecordsFunctionExecutor(List<ParameterValueOriginPair> parameterValuePairs, FunctionLoader functionLoader) {
         this.parameterValuePairs = parameterValuePairs;
         this.functionLoader = functionLoader;
     }
 
-    public List<?> execute(Record record) throws IOException {
+    @Override
+    public List<?> execute(Map<String, Record> records) throws IOException {
         final ArrayList<Term> fnTerms = new ArrayList<>();
         final HashMap<String, Object> args =  new HashMap<>();
 
@@ -31,16 +32,16 @@ public List<?> execute(Record record) throws IOException {
 
             pv.getParameterGenerators().forEach(parameterGen -> {
                 try {
-                    parameters.addAll(parameterGen.generate(record));
+                    parameters.addAll(parameterGen.generate(records.get("child")));
                 } catch (IOException e) {
                     //todo be more nice and gentle
                     e.printStackTrace();
                 }
             });
 
-            pv.getValueGenerators().forEach(valueGenerator -> {
+            pv.getValueGeneratorPairs().forEach(pair -> {
                 try {
-                    values.addAll(valueGenerator.generate(record));
+                    values.addAll(pair.getTermGenerator().generate(records.get(pair.getOrigin())));
                 } catch (IOException e) {
                     //todo be more nice and gentle
                     e.printStackTrace();
@@ -51,18 +52,13 @@ public List<?> execute(Record record) throws IOException {
                 fnTerms.add(values.get(0));
             } else {
                 parameters.forEach(parameter -> {
-                   values.forEach(value -> {
-                       args.put(parameter.getValue(), value.getValue());
-                   }) ;
+                    values.forEach(value -> {
+                        args.put(parameter.getValue(), value.getValue());
+                    }) ;
                 });
             }
         });
 
-        if (fnTerms.isEmpty()) {
-            //todo throw error
-            return new ArrayList<>();
-        } else {
-            return functionLoader.getFunction(fnTerms.get(0)).execute(args);
-        }
+        return functionLoader.getFunction(fnTerms.get(0)).execute(args);
     }
-}
+}

src/main/java/be/ugent/rml/functions/DynamicSingleRecordFunctionExecutor.java

@@ -0,0 +1,23 @@
+package be.ugent.rml.functions;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class DynamicSingleRecordFunctionExecutor extends AbstractSingleRecordFunctionExecutor {
+
+    public DynamicSingleRecordFunctionExecutor(List<ParameterValuePair> parameterValuePairs, FunctionLoader functionLoader) {
+        ArrayList<ParameterValueOriginPair> pairs = new ArrayList<>();
+
+        parameterValuePairs.forEach(pair -> {
+            ArrayList<TermGeneratorOriginPair> objectGeneratorOriginPairs = new ArrayList<>();
+
+            pair.getValueGenerators().forEach(vGen -> {
+                objectGeneratorOriginPairs.add(new TermGeneratorOriginPair(vGen, "_default"));
+            });
+
+            pairs.add(new ParameterValueOriginPair(pair.getParameterGenerators(), objectGeneratorOriginPairs));
+        });
+
+        functionExecutor = new DynamicMultipleRecordsFunctionExecutor(pairs, functionLoader);
+    }
+}

src/main/java/be/ugent/rml/functions/FunctionUtils.java

@@ -58,6 +58,10 @@ public static Class<?>[] parseFunctionParameters(QuadStore store, List<Term> par
         return args;
     }
 
+    public static boolean isResultsTrue(List<?> results) {
+        return !results.isEmpty() && results.get(0).equals("true");
+    }
+
     private static Class getParamType(Term type) {
         String typeStr = type.getValue();
 

src/main/java/be/ugent/rml/functions/JoinConditionFunctionExecutor.java

@@ -0,0 +1,10 @@
+package be.ugent.rml.functions;
+
+import be.ugent.rml.records.Record;
+
+import java.io.IOException;
+
+public interface JoinConditionFunctionExecutor {
+
+    boolean execute(Record child, Record parent) throws IOException;
+}

src/main/java/be/ugent/rml/functions/MultipleRecordsFunctionExecutor.java

@@ -0,0 +1,12 @@
+package be.ugent.rml.functions;
+
+import be.ugent.rml.records.Record;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+public interface MultipleRecordsFunctionExecutor {
+
+    List<?> execute(Map<String, Record> records) throws IOException;
+}

src/main/java/be/ugent/rml/functions/ParameterValueOriginPair.java

@@ -0,0 +1,24 @@
+package be.ugent.rml.functions;
+
+import be.ugent.rml.termgenerator.TermGenerator;
+
+import java.util.List;
+
+public class ParameterValueOriginPair {
+
+    private List<TermGenerator> parameterGenerators;
+    private List<TermGeneratorOriginPair> valueGeneratorPairs;
+
+    public ParameterValueOriginPair(List<TermGenerator> parameterGenerators, List<TermGeneratorOriginPair> valueGeneratorPairs) {
+        this.parameterGenerators = parameterGenerators;
+        this.valueGeneratorPairs = valueGeneratorPairs;
+    }
+
+    public List<TermGenerator> getParameterGenerators() {
+        return parameterGenerators;
+    }
+
+    public List<TermGeneratorOriginPair> getValueGeneratorPairs() {
+        return valueGeneratorPairs;
+    }
+}

src/main/java/be/ugent/rml/functions/FunctionExecutor.java → src/main/java/be/ugent/rml/functions/SingleRecordFunctionExecutor.java

@@ -5,7 +5,7 @@
 import java.io.IOException;
 import java.util.List;
 
-public interface FunctionExecutor {
+public interface SingleRecordFunctionExecutor {
 
     List<?> execute(Record record) throws IOException;
 }