You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@jena.apache.org by an...@apache.org on 2012/02/11 23:29:48 UTC

svn commit: r1243171 - in /incubator/jena/Jena2/ARQ/trunk/src/main/java/com/hp/hpl/jena/sparql: algebra/op/OpUnion.java algebra/optimize/TransformPathFlatternStd.java path/PathVisitorByType.java

Author: andy
Date: Sat Feb 11 22:29:48 2012
New Revision: 1243171

URL: http://svn.apache.org/viewvc?rev=1243171&view=rev
Log:
Provide as-per-spec path transformation.  Not used for execution as it generates op code which is inefficient.

Added:
    incubator/jena/Jena2/ARQ/trunk/src/main/java/com/hp/hpl/jena/sparql/path/PathVisitorByType.java
Modified:
    incubator/jena/Jena2/ARQ/trunk/src/main/java/com/hp/hpl/jena/sparql/algebra/op/OpUnion.java
    incubator/jena/Jena2/ARQ/trunk/src/main/java/com/hp/hpl/jena/sparql/algebra/optimize/TransformPathFlatternStd.java

Modified: incubator/jena/Jena2/ARQ/trunk/src/main/java/com/hp/hpl/jena/sparql/algebra/op/OpUnion.java
URL: http://svn.apache.org/viewvc/incubator/jena/Jena2/ARQ/trunk/src/main/java/com/hp/hpl/jena/sparql/algebra/op/OpUnion.java?rev=1243171&r1=1243170&r2=1243171&view=diff
==============================================================================
--- incubator/jena/Jena2/ARQ/trunk/src/main/java/com/hp/hpl/jena/sparql/algebra/op/OpUnion.java (original)
+++ incubator/jena/Jena2/ARQ/trunk/src/main/java/com/hp/hpl/jena/sparql/algebra/op/OpUnion.java Sat Feb 11 22:29:48 2012
@@ -30,6 +30,8 @@ public class OpUnion extends Op2
     {
         if ( left == null )
             return right ;
+        if ( right == null )
+            return left ;
 
         return new OpUnion(left, right) ;
     }

Modified: incubator/jena/Jena2/ARQ/trunk/src/main/java/com/hp/hpl/jena/sparql/algebra/optimize/TransformPathFlatternStd.java
URL: http://svn.apache.org/viewvc/incubator/jena/Jena2/ARQ/trunk/src/main/java/com/hp/hpl/jena/sparql/algebra/optimize/TransformPathFlatternStd.java?rev=1243171&r1=1243170&r2=1243171&view=diff
==============================================================================
--- incubator/jena/Jena2/ARQ/trunk/src/main/java/com/hp/hpl/jena/sparql/algebra/optimize/TransformPathFlatternStd.java (original)
+++ incubator/jena/Jena2/ARQ/trunk/src/main/java/com/hp/hpl/jena/sparql/algebra/optimize/TransformPathFlatternStd.java Sat Feb 11 22:29:48 2012
@@ -18,6 +18,9 @@
 
 package com.hp.hpl.jena.sparql.algebra.optimize;
 
+import java.util.ArrayList ;
+import java.util.List ;
+
 import com.hp.hpl.jena.graph.Node ;
 import com.hp.hpl.jena.graph.Triple ;
 import com.hp.hpl.jena.sparql.ARQConstants ;
@@ -58,16 +61,19 @@ public class TransformPathFlatternStd ex
         if ( r == null )
         {
             if ( op == null )
-            {
-                TriplePath tp = new TriplePath(subject, path, object) ;
-                op = new OpPath(tp) ;
-            }
+                op = make(subject, path, object) ;
             return op ;
         }
             
         return r ;
     }
     
+    static OpPath make(Node subject, Path path, Node object)
+    {
+        TriplePath tp = new TriplePath(subject, path, object) ;
+        return new OpPath(tp) ;
+    }
+    
     static VarAlloc varAlloc = new VarAlloc(ARQConstants.allocVarAnonMarker+"Q") ;
     
     static Op join(Op op1, Op op2)
@@ -79,6 +85,16 @@ public class TransformPathFlatternStd ex
         return OpJoin.create(op1, op2) ;
     }
     
+    static Op union(Op left, Op right)
+    {
+        if ( left == null )
+            return right ;
+        if ( right == null )
+            return left ;
+
+        return new OpUnion(left, right) ;
+    }
+    
     static class PathTransform implements PathVisitor
     {
         private final Node subject ;
@@ -109,10 +125,52 @@ public class TransformPathFlatternStd ex
             result = op  ;
         }
         
+        /*
+         * Reverse transformations.
+         * X !(^:uri1|...|^:urin)Y                      ==>  ^(X !(:uri1|...|:urin) Y)
+         * Split into forward and reverse.
+         * X !(:uri1|...|:urii|^:urii+1|...|^:urim) Y   ==>  { X !(:uri1|...|:urii|)Y } UNION { X !(^:urii+1|...|^:urim) Y } 
+         */
         @Override
         public void visit(P_NegPropSet pathNotOneOf)
         {
-            // No change.
+            Op opFwd = null ;
+            Op opBwd = null ;
+            List<P_Path0> forwards = new ArrayList<P_Path0>() ;
+            List<P_Path0> backwards = new ArrayList<P_Path0>() ;
+            
+            for ( P_Path0 p :  pathNotOneOf.getNodes() )
+            {
+                if ( p.isForward() )
+                    forwards.add(p) ;
+                else
+                    backwards.add(p) ;
+            }
+                
+            if ( ! forwards.isEmpty() )
+            {
+                P_NegPropSet pFwd = new P_NegPropSet() ;
+                for ( P_Path0 p : forwards )
+                    pFwd.add(p) ;
+                opFwd = make(subject, pFwd, object) ;
+            }
+            
+            if ( ! backwards.isEmpty() )
+            {
+                // Could reverse here.
+                P_NegPropSet pBwd = new P_NegPropSet() ;
+                for ( P_Path0 p : backwards )
+                    pBwd.add(p) ;
+                opBwd = make(subject, pBwd, object) ;
+            }
+            
+            if ( opFwd == null && opBwd == null )
+            {
+                result = make(subject, pathNotOneOf, object) ;
+                return ; 
+            }
+            
+            result = union(opFwd, opBwd) ;
         }
         
         @Override
@@ -134,7 +192,7 @@ public class TransformPathFlatternStd ex
             {
                 Path p = PathFactory.pathFixedLength(pathMod.getSubPath(), i) ;
                 Op sub = transformPath(null, subject, p, object) ;
-                op = OpUnion.create(op, sub) ;
+                op = union(op, sub) ;
             }
             result = op ;
         }
@@ -189,7 +247,7 @@ public class TransformPathFlatternStd ex
         {
             Op op1 = transformPath(null, subject, pathAlt.getLeft() , object) ;
             Op op2 = transformPath(null, subject, pathAlt.getRight() , object) ;
-            result = OpUnion.create(op1, op2) ;
+            result = union(op1, op2) ;
         }
         
         @Override

Added: incubator/jena/Jena2/ARQ/trunk/src/main/java/com/hp/hpl/jena/sparql/path/PathVisitorByType.java
URL: http://svn.apache.org/viewvc/incubator/jena/Jena2/ARQ/trunk/src/main/java/com/hp/hpl/jena/sparql/path/PathVisitorByType.java?rev=1243171&view=auto
==============================================================================
--- incubator/jena/Jena2/ARQ/trunk/src/main/java/com/hp/hpl/jena/sparql/path/PathVisitorByType.java (added)
+++ incubator/jena/Jena2/ARQ/trunk/src/main/java/com/hp/hpl/jena/sparql/path/PathVisitorByType.java Sat Feb 11 22:29:48 2012
@@ -0,0 +1,61 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.hp.hpl.jena.sparql.path;
+
+
+public abstract class PathVisitorByType implements PathVisitor
+{
+    public abstract void visitNegPS(P_NegPropSet path) ;
+    public abstract void visit0(P_Path0 path) ;
+    public abstract void visit1(P_Path1 path) ;
+    public abstract void visit2(P_Path2 path) ;
+
+    @Override
+    public void visit(P_Link pathNode)              { visit0(pathNode) ; }
+
+    @Override
+    public void visit(P_ReverseLink pathNode)       { visit0(pathNode) ; }
+
+    @Override
+    public void visit(P_NegPropSet pathNotOneOf)    { visitNegPS(pathNotOneOf) ; }
+
+    @Override
+    public void visit(P_Inverse inversePath)        { visit1(inversePath) ; }
+
+    @Override
+    public void visit(P_Mod pathMod)                { visit1(pathMod) ; }
+
+    @Override
+    public void visit(P_FixedLength pFixedLength)   { visit1(pFixedLength) ; }
+
+    @Override
+    public void visit(P_ZeroOrOne path)             { visit1(path) ; }
+
+    @Override
+    public void visit(P_ZeroOrMore path)            { visit1(path) ; }
+
+    @Override
+    public void visit(P_OneOrMore path)             { visit1(path) ; }
+
+    @Override
+    public void visit(P_Alt pathAlt)                { visit2(pathAlt) ; }
+
+    @Override
+    public void visit(P_Seq pathSeq)                { visit2(pathSeq) ; }
+}