(jena) branch main updated: GH 1361 Respect the filterFunctors flag during backward chaining

[an...@apache.org]

This is an automated email from the ASF dual-hosted git repository.

afs pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/jena.git


The following commit(s) were added to refs/heads/main by this push:
     new 2ae015ae7f GH 1361 Respect the filterFunctors flag during backward chaining
2ae015ae7f is described below

commit 2ae015ae7f791b1ff606c1c3cbb1f61a0c6c03db
Author: Thomas Thelen <to...@gmail.com>
AuthorDate: Wed Jun 24 12:51:53 2026 -0700

    GH 1361 Respect the filterFunctors flag during backward chaining
---
 .../jena/reasoner/rulesys/GenericRuleReasoner.java |  1 +
 .../reasoner/rulesys/LPBackwardRuleInfGraph.java   | 17 +++++++++++++-
 .../reasoner/rulesys/test/TestGenericRules.java    | 27 ++++++++++++++++++++++
 3 files changed, 44 insertions(+), 1 deletion(-)

diff --git a/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/GenericRuleReasoner.java b/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/GenericRuleReasoner.java
index e7f303a497..9513b44aa0 100644
--- a/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/GenericRuleReasoner.java
+++ b/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/GenericRuleReasoner.java
@@ -387,6 +387,7 @@ public class GenericRuleReasoner extends FBRuleReasoner {
         } else if (mode == BACKWARD) {
             graph = new LPBackwardRuleInfGraph(this, getBruleStore(), data, schemaArg);
             ((LPBackwardRuleInfGraph)graph).setTraceOn(traceOn);
+            ((LPBackwardRuleInfGraph)graph).setFunctorFiltering(filterFunctors);
         } else {
             List<Rule> ruleSet = ((FBRuleInfGraph)schemaArg).getRules();
             FBRuleInfGraph fbgraph = new FBRuleInfGraph(this, ruleSet, schemaArg);
diff --git a/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/LPBackwardRuleInfGraph.java b/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/LPBackwardRuleInfGraph.java
index 718a8206b9..a511dc4c53 100644
--- a/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/LPBackwardRuleInfGraph.java
+++ b/jena-core/src/main/java/org/apache/jena/reasoner/rulesys/LPBackwardRuleInfGraph.java
@@ -58,6 +58,9 @@ public class LPBackwardRuleInfGraph extends BaseInfGraph implements BackwardRule
     /** Cache of temporary property values inferred through getTemp calls */
     protected TempNodeCache tempNodecache;
 
+    /** Flag, if true then functor-valued literals are filtered from find results */
+    protected boolean filterFunctors = true;
+
     static Logger logger = LoggerFactory.getLogger(LPBackwardRuleInfGraph.class);
 
 //  =======================================================================
@@ -172,7 +175,11 @@ public class LPBackwardRuleInfGraph extends BaseInfGraph implements BackwardRule
         if (continuation != null) {
             result = result.andThen(continuation.find(pattern));
         }
-        return result.filterDrop(Functor.acceptFilter);
+        if (filterFunctors) {
+            return result.filterDrop(Functor.acceptFilter);
+        } else {
+            return result;
+        }
     }
 
     /**
@@ -260,6 +267,14 @@ public class LPBackwardRuleInfGraph extends BaseInfGraph implements BackwardRule
         }
     }
 
+    /**
+     * Set to true to cause functor-valued literals to be dropped from rule output.
+     * Default is true.
+     */
+    public void setFunctorFiltering(boolean param) {
+        filterFunctors = param;
+    }
+
     /**
      * Set the state of the trace flag. If set to true then rule firings
      * are logged out to the Log at "INFO" level.
diff --git a/jena-core/src/test/java/org/apache/jena/reasoner/rulesys/test/TestGenericRules.java b/jena-core/src/test/java/org/apache/jena/reasoner/rulesys/test/TestGenericRules.java
index 583a2e1742..55877c4c91 100644
--- a/jena-core/src/test/java/org/apache/jena/reasoner/rulesys/test/TestGenericRules.java
+++ b/jena-core/src/test/java/org/apache/jena/reasoner/rulesys/test/TestGenericRules.java
@@ -325,6 +325,33 @@ public class TestGenericRules extends TestCase {
               } );
     }
 
+    /**
+     * Test that functor filtering is honored in backward mode.
+     */
+    public void testBackwardFunctorFilter() {
+        Graph data = createGraphForTest();
+        data.add(Triple.create(a, r, b));
+        data.add(Triple.create(a, p, s));
+        List<Rule> rules = Rule.parseRules( "[r0: (?x q func(?y, ?z)) <- (?x r ?y) (?x p ?z)]" );
+        GenericRuleReasoner reasoner = (GenericRuleReasoner)GenericRuleReasonerFactory.theInstance().create(null);
+        reasoner.setRules(rules);
+        reasoner.setMode(GenericRuleReasoner.BACKWARD);
+
+        // Default: functors are filtered out
+        InfGraph infgraph = reasoner.bind(data);
+        TestUtil.assertIteratorValues(this,
+              infgraph.find(null, q, null), new Object[] {
+              } );
+
+        // With filtering disabled: functor triples should be visible
+        reasoner.setFunctorFiltering(false);
+        infgraph = reasoner.bind(data);
+        TestUtil.assertIteratorValues(this,
+              infgraph.find(null, q, null), new Object[] {
+                  Triple.create(a, q, Functor.makeFunctorNode("func", new Node[]{b, s}))
+              } );
+    }
+
     /**
      * Test recursive rules involving functors
      * May lock up in there is a bug.